
// Generated from src/cypher/grammar/Lcypher.g4 by ANTLR 4.13.0


#include "LcypherVisitor.h"

#include "LcypherParser.h"


using namespace antlrcpp;
using namespace parser;

using namespace antlr4;

namespace {

struct LcypherParserStaticData final {
  LcypherParserStaticData(std::vector<std::string> ruleNames,
                        std::vector<std::string> literalNames,
                        std::vector<std::string> symbolicNames)
      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
        symbolicNames(std::move(symbolicNames)),
        vocabulary(this->literalNames, this->symbolicNames) {}

  LcypherParserStaticData(const LcypherParserStaticData&) = delete;
  LcypherParserStaticData(LcypherParserStaticData&&) = delete;
  LcypherParserStaticData& operator=(const LcypherParserStaticData&) = delete;
  LcypherParserStaticData& operator=(LcypherParserStaticData&&) = delete;

  std::vector<antlr4::dfa::DFA> decisionToDFA;
  antlr4::atn::PredictionContextCache sharedContextCache;
  const std::vector<std::string> ruleNames;
  const std::vector<std::string> literalNames;
  const std::vector<std::string> symbolicNames;
  const antlr4::dfa::Vocabulary vocabulary;
  antlr4::atn::SerializedATNView serializedATN;
  std::unique_ptr<antlr4::atn::ATN> atn;
};

::antlr4::internal::OnceFlag lcypherParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
LcypherParserStaticData *lcypherParserStaticData = nullptr;

void lcypherParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  if (lcypherParserStaticData != nullptr) {
    return;
  }
#else
  assert(lcypherParserStaticData == nullptr);
#endif
  auto staticData = std::make_unique<LcypherParserStaticData>(
    std::vector<std::string>{
      "oC_Cypher", "oC_Statement", "oC_Query", "oC_RegularQuery", "oC_Union", 
      "oC_SingleQuery", "oC_SinglePartQuery", "oC_MultiPartQuery", "oC_UpdatingClause", 
      "oC_ReadingClause", "oC_Match", "oC_Unwind", "oC_Merge", "oC_MergeAction", 
      "oC_Create", "oC_Set", "oC_SetItem", "oC_Delete", "oC_Remove", "oC_RemoveItem", 
      "oC_InQueryCall", "oC_StandaloneCall", "oC_YieldItems", "oC_YieldItem", 
      "oC_With", "oC_Return", "oC_ReturnBody", "oC_ReturnItems", "oC_ReturnItem", 
      "oC_Order", "oC_Skip", "oC_Limit", "oC_SortItem", "oC_Hint", "oC_Where", 
      "oC_Pattern", "oC_PatternPart", "oC_AnonymousPatternPart", "oC_PatternElement", 
      "oC_NodePattern", "oC_PatternElementChain", "oC_RelationshipPattern", 
      "oC_RelationshipDetail", "oC_Properties", "oC_RelationshipTypes", 
      "oC_NodeLabels", "oC_NodeLabel", "oC_RangeLiteral", "oC_LabelName", 
      "oC_RelTypeName", "oC_Expression", "oC_OrExpression", "oC_XorExpression", 
      "oC_AndExpression", "oC_NotExpression", "oC_ComparisonExpression", 
      "oC_AddOrSubtractExpression", "oC_MultiplyDivideModuloExpression", 
      "oC_PowerOfExpression", "oC_UnaryAddOrSubtractExpression", "oC_StringListNullOperatorExpression", 
      "oC_ListOperatorExpression", "oC_StringOperatorExpression", "oC_NullOperatorExpression", 
      "oC_PropertyOrLabelsExpression", "oC_Atom", "oC_Literal", "oC_BooleanLiteral", 
      "oC_ListLiteral", "oC_PartialComparisonExpression", "oC_ParenthesizedExpression", 
      "oC_RelationshipsPattern", "oC_FilterExpression", "oC_IdInColl", "oC_FunctionInvocation", 
      "oC_FunctionName", "oC_ExplicitProcedureInvocation", "oC_ImplicitProcedureInvocation", 
      "oC_ProcedureResultField", "oC_ProcedureName", "oC_Namespace", "oC_ListComprehension", 
      "oC_PatternComprehension", "oC_PropertyLookup", "oC_CaseExpression", 
      "oC_CaseAlternatives", "oC_Variable", "oC_NumberLiteral", "oC_MapLiteral", 
      "oC_Parameter", "oC_PropertyExpression", "oC_PropertyKeyName", "oC_IntegerLiteral", 
      "oC_DoubleLiteral", "oC_SchemaName", "oC_SymbolicName", "oC_ReservedWord", 
      "oC_LeftArrowHead", "oC_RightArrowHead", "oC_Dash"
    },
    std::vector<std::string>{
      "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", 
      "':'", "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'<>'", "'<'", 
      "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'\\u27E8'", "'\\u3008'", 
      "'\\uFE64'", "'\\uFF1C'", "'\\u27E9'", "'\\u3009'", "'\\uFE65'", "'\\uFF1E'", 
      "'\\u00AD'", "'\\u2010'", "'\\u2011'", "'\\u2012'", "'\\u2013'", "'\\u2014'", 
      "'\\u2015'", "'\\u2212'", "'\\uFE58'", "'\\uFE63'", "'\\uFF0D'", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'0'"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "EXPLAIN", "PROFILE", 
      "UNION", "ALL", "OPTIONAL_", "MATCH", "UNWIND", "AS", "MERGE", "ON", 
      "CREATE", "SET", "DETACH", "DELETE_", "REMOVE", "CALL", "YIELD", "WITH", 
      "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT", "ASCENDING", 
      "ASC", "DESCENDING", "DESC", "USING", "JOIN", "START", "WHERE", "OR", 
      "XOR", "AND", "NOT", "IN", "STARTS", "ENDS", "CONTAINS", "REGEXP", 
      "IS", "NULL_", "COUNT", "ANY", "NONE", "SINGLE", "TRUE_", "FALSE_", 
      "EXISTS", "CASE", "ELSE", "END", "WHEN", "THEN", "StringLiteral", 
      "EscapedChar", "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", 
      "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", 
      "ZeroDigit", "ExponentDecimalReal", "RegularDecimalReal", "FILTER", 
      "EXTRACT", "UnescapedSymbolicName", "CONSTRAINT", "DO", "FOR", "REQUIRE", 
      "UNIQUE", "MANDATORY", "SCALAR", "OF", "ADD", "DROP", "IdentifierStart", 
      "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "Comment"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,133,1594,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
  	2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
  	7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
  	7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
  	7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
  	7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
  	7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
  	7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
  	7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
  	7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
  	7,98,2,99,7,99,1,0,3,0,202,8,0,1,0,1,0,3,0,206,8,0,1,0,3,0,209,8,0,1,
  	0,3,0,212,8,0,1,0,1,0,1,1,1,1,1,1,3,1,219,8,1,1,1,1,1,1,1,3,1,224,8,1,
  	1,1,3,1,227,8,1,1,2,1,2,3,2,231,8,2,1,3,1,3,3,3,235,8,3,1,3,5,3,238,8,
  	3,10,3,12,3,241,9,3,1,4,1,4,1,4,1,4,3,4,247,8,4,1,4,1,4,1,4,3,4,252,8,
  	4,1,4,3,4,255,8,4,1,5,1,5,3,5,259,8,5,1,6,1,6,3,6,263,8,6,5,6,265,8,6,
  	10,6,12,6,268,9,6,1,6,1,6,1,6,3,6,273,8,6,5,6,275,8,6,10,6,12,6,278,9,
  	6,1,6,1,6,3,6,282,8,6,1,6,5,6,285,8,6,10,6,12,6,288,9,6,1,6,3,6,291,8,
  	6,1,6,3,6,294,8,6,3,6,296,8,6,1,7,1,7,3,7,300,8,7,5,7,302,8,7,10,7,12,
  	7,305,9,7,1,7,1,7,3,7,309,8,7,5,7,311,8,7,10,7,12,7,314,9,7,1,7,1,7,3,
  	7,318,8,7,4,7,320,8,7,11,7,12,7,321,1,7,1,7,1,8,1,8,1,8,1,8,1,8,3,8,331,
  	8,8,1,9,1,9,1,9,3,9,336,8,9,1,10,1,10,3,10,340,8,10,1,10,1,10,3,10,344,
  	8,10,1,10,1,10,3,10,348,8,10,1,10,5,10,351,8,10,10,10,12,10,354,9,10,
  	1,10,3,10,357,8,10,1,10,3,10,360,8,10,1,11,1,11,3,11,364,8,11,1,11,1,
  	11,1,11,1,11,1,11,1,11,1,12,1,12,3,12,374,8,12,1,12,1,12,1,12,5,12,379,
  	8,12,10,12,12,12,382,9,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
  	1,13,3,13,394,8,13,1,14,1,14,3,14,398,8,14,1,14,1,14,1,15,1,15,3,15,404,
  	8,15,1,15,1,15,3,15,408,8,15,1,15,1,15,3,15,412,8,15,1,15,5,15,415,8,
  	15,10,15,12,15,418,9,15,1,16,1,16,3,16,422,8,16,1,16,1,16,3,16,426,8,
  	16,1,16,1,16,1,16,1,16,3,16,432,8,16,1,16,1,16,3,16,436,8,16,1,16,1,16,
  	1,16,1,16,3,16,442,8,16,1,16,1,16,3,16,446,8,16,1,16,1,16,1,16,1,16,3,
  	16,452,8,16,1,16,1,16,3,16,456,8,16,1,17,1,17,3,17,460,8,17,1,17,1,17,
  	3,17,464,8,17,1,17,1,17,3,17,468,8,17,1,17,1,17,3,17,472,8,17,1,17,5,
  	17,475,8,17,10,17,12,17,478,9,17,1,18,1,18,1,18,1,18,3,18,484,8,18,1,
  	18,1,18,3,18,488,8,18,1,18,5,18,491,8,18,10,18,12,18,494,9,18,1,19,1,
  	19,1,19,1,19,3,19,500,8,19,1,20,1,20,1,20,1,20,3,20,506,8,20,1,20,1,20,
  	1,20,3,20,511,8,20,1,21,1,21,1,21,1,21,3,21,517,8,21,1,21,1,21,1,21,1,
  	21,3,21,523,8,21,1,22,1,22,1,22,3,22,528,8,22,1,22,1,22,3,22,532,8,22,
  	1,22,5,22,535,8,22,10,22,12,22,538,9,22,3,22,540,8,22,1,22,3,22,543,8,
  	22,1,22,3,22,546,8,22,1,23,1,23,1,23,1,23,1,23,3,23,553,8,23,1,23,1,23,
  	1,24,1,24,3,24,559,8,24,1,24,3,24,562,8,24,1,24,1,24,1,24,3,24,567,8,
  	24,1,24,3,24,570,8,24,1,25,1,25,3,25,574,8,25,1,25,3,25,577,8,25,1,25,
  	1,25,1,25,1,26,1,26,1,26,3,26,585,8,26,1,26,1,26,3,26,589,8,26,1,26,1,
  	26,3,26,593,8,26,1,27,1,27,3,27,597,8,27,1,27,1,27,3,27,601,8,27,1,27,
  	5,27,604,8,27,10,27,12,27,607,9,27,1,27,1,27,3,27,611,8,27,1,27,1,27,
  	3,27,615,8,27,1,27,5,27,618,8,27,10,27,12,27,621,9,27,3,27,623,8,27,1,
  	28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,632,8,28,1,29,1,29,1,29,1,29,1,
  	29,1,29,1,29,3,29,641,8,29,1,29,5,29,644,8,29,10,29,12,29,647,9,29,1,
  	30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,32,1,32,3,32,659,8,32,1,32,3,
  	32,662,8,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
  	33,1,33,1,33,3,33,678,8,33,1,34,1,34,1,34,1,34,1,35,1,35,3,35,686,8,35,
  	1,35,1,35,3,35,690,8,35,1,35,5,35,693,8,35,10,35,12,35,696,9,35,1,36,
  	1,36,3,36,700,8,36,1,36,1,36,3,36,704,8,36,1,36,1,36,1,36,3,36,709,8,
  	36,1,37,1,37,1,38,1,38,3,38,715,8,38,1,38,5,38,718,8,38,10,38,12,38,721,
  	9,38,1,38,1,38,1,38,1,38,3,38,727,8,38,1,39,1,39,3,39,731,8,39,1,39,1,
  	39,3,39,735,8,39,3,39,737,8,39,1,39,1,39,3,39,741,8,39,3,39,743,8,39,
  	1,39,1,39,3,39,747,8,39,3,39,749,8,39,1,39,1,39,1,40,1,40,3,40,755,8,
  	40,1,40,1,40,1,41,1,41,3,41,761,8,41,1,41,1,41,3,41,765,8,41,1,41,3,41,
  	768,8,41,1,41,3,41,771,8,41,1,41,1,41,3,41,775,8,41,1,41,1,41,1,41,1,
  	41,3,41,781,8,41,1,41,1,41,3,41,785,8,41,1,41,3,41,788,8,41,1,41,3,41,
  	791,8,41,1,41,1,41,1,41,1,41,3,41,797,8,41,1,41,3,41,800,8,41,1,41,3,
  	41,803,8,41,1,41,1,41,3,41,807,8,41,1,41,1,41,1,41,1,41,3,41,813,8,41,
  	1,41,3,41,816,8,41,1,41,3,41,819,8,41,1,41,1,41,3,41,823,8,41,1,42,1,
  	42,3,42,827,8,42,1,42,1,42,3,42,831,8,42,3,42,833,8,42,1,42,1,42,3,42,
  	837,8,42,3,42,839,8,42,1,42,3,42,842,8,42,1,42,1,42,3,42,846,8,42,3,42,
  	848,8,42,1,42,1,42,1,43,1,43,3,43,854,8,43,1,44,1,44,3,44,858,8,44,1,
  	44,1,44,3,44,862,8,44,1,44,1,44,3,44,866,8,44,1,44,3,44,869,8,44,1,44,
  	5,44,872,8,44,10,44,12,44,875,9,44,1,45,1,45,3,45,879,8,45,1,45,5,45,
  	882,8,45,10,45,12,45,885,9,45,1,46,1,46,3,46,889,8,46,1,46,1,46,1,47,
  	1,47,3,47,895,8,47,1,47,1,47,3,47,899,8,47,3,47,901,8,47,1,47,1,47,3,
  	47,905,8,47,1,47,1,47,3,47,909,8,47,3,47,911,8,47,3,47,913,8,47,1,48,
  	1,48,1,49,1,49,1,50,1,50,1,51,1,51,1,51,1,51,1,51,5,51,926,8,51,10,51,
  	12,51,929,9,51,1,52,1,52,1,52,1,52,1,52,5,52,936,8,52,10,52,12,52,939,
  	9,52,1,53,1,53,1,53,1,53,1,53,5,53,946,8,53,10,53,12,53,949,9,53,1,54,
  	1,54,3,54,953,8,54,5,54,955,8,54,10,54,12,54,958,9,54,1,54,1,54,1,55,
  	1,55,3,55,964,8,55,1,55,5,55,967,8,55,10,55,12,55,970,9,55,1,56,1,56,
  	3,56,974,8,56,1,56,1,56,3,56,978,8,56,1,56,1,56,3,56,982,8,56,1,56,1,
  	56,3,56,986,8,56,1,56,5,56,989,8,56,10,56,12,56,992,9,56,1,57,1,57,3,
  	57,996,8,57,1,57,1,57,3,57,1000,8,57,1,57,1,57,3,57,1004,8,57,1,57,1,
  	57,3,57,1008,8,57,1,57,1,57,3,57,1012,8,57,1,57,1,57,3,57,1016,8,57,1,
  	57,5,57,1019,8,57,10,57,12,57,1022,9,57,1,58,1,58,3,58,1026,8,58,1,58,
  	1,58,3,58,1030,8,58,1,58,5,58,1033,8,58,10,58,12,58,1036,9,58,1,59,1,
  	59,3,59,1040,8,59,5,59,1042,8,59,10,59,12,59,1045,9,59,1,59,1,59,1,60,
  	1,60,1,60,1,60,5,60,1053,8,60,10,60,12,60,1056,9,60,1,61,1,61,1,61,3,
  	61,1061,8,61,1,61,1,61,3,61,1065,8,61,1,61,1,61,1,61,1,61,1,61,3,61,1072,
  	8,61,1,61,1,61,3,61,1076,8,61,1,61,1,61,3,61,1080,8,61,1,61,3,61,1083,
  	8,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,
  	1097,8,62,1,62,3,62,1100,8,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,
  	1,63,1,63,1,63,1,63,3,63,1114,8,63,1,64,1,64,3,64,1118,8,64,1,64,5,64,
  	1121,8,64,10,64,12,64,1124,9,64,1,64,3,64,1127,8,64,1,64,3,64,1130,8,
  	64,1,65,1,65,1,65,1,65,1,65,3,65,1137,8,65,1,65,1,65,3,65,1141,8,65,1,
  	65,1,65,3,65,1145,8,65,1,65,1,65,1,65,1,65,1,65,3,65,1152,8,65,1,65,1,
  	65,3,65,1156,8,65,1,65,1,65,3,65,1160,8,65,1,65,1,65,1,65,1,65,3,65,1166,
  	8,65,1,65,1,65,3,65,1170,8,65,1,65,1,65,3,65,1174,8,65,1,65,1,65,1,65,
  	1,65,3,65,1180,8,65,1,65,1,65,3,65,1184,8,65,1,65,1,65,3,65,1188,8,65,
  	1,65,1,65,1,65,1,65,3,65,1194,8,65,1,65,1,65,3,65,1198,8,65,1,65,1,65,
  	3,65,1202,8,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1210,8,65,1,66,1,66,
  	1,66,1,66,1,66,1,66,3,66,1218,8,66,1,67,1,67,1,68,1,68,3,68,1224,8,68,
  	1,68,1,68,3,68,1228,8,68,1,68,1,68,3,68,1232,8,68,1,68,1,68,3,68,1236,
  	8,68,5,68,1238,8,68,10,68,12,68,1241,9,68,3,68,1243,8,68,1,68,1,68,1,
  	69,1,69,3,69,1249,8,69,1,69,1,69,1,69,3,69,1254,8,69,1,69,1,69,1,69,3,
  	69,1259,8,69,1,69,1,69,1,69,3,69,1264,8,69,1,69,1,69,1,69,3,69,1269,8,
  	69,1,69,1,69,1,69,3,69,1274,8,69,1,69,3,69,1277,8,69,1,70,1,70,3,70,1281,
  	8,70,1,70,1,70,3,70,1285,8,70,1,70,1,70,1,71,1,71,3,71,1291,8,71,1,71,
  	4,71,1294,8,71,11,71,12,71,1295,1,72,1,72,3,72,1300,8,72,1,72,3,72,1303,
  	8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,3,74,1313,8,74,1,74,1,74,
  	3,74,1317,8,74,1,74,1,74,3,74,1321,8,74,3,74,1323,8,74,1,74,1,74,3,74,
  	1327,8,74,1,74,1,74,3,74,1331,8,74,1,74,1,74,3,74,1335,8,74,5,74,1337,
  	8,74,10,74,12,74,1340,9,74,3,74,1342,8,74,1,74,1,74,1,75,1,75,1,75,1,
  	75,3,75,1350,8,75,1,76,1,76,3,76,1354,8,76,1,76,1,76,3,76,1358,8,76,1,
  	76,1,76,3,76,1362,8,76,1,76,1,76,3,76,1366,8,76,1,76,1,76,3,76,1370,8,
  	76,5,76,1372,8,76,10,76,12,76,1375,9,76,3,76,1377,8,76,1,76,1,76,1,77,
  	1,77,1,78,1,78,1,79,1,79,1,79,1,80,1,80,1,80,5,80,1391,8,80,10,80,12,
  	80,1394,9,80,1,81,1,81,3,81,1398,8,81,1,81,1,81,3,81,1402,8,81,1,81,1,
  	81,3,81,1406,8,81,1,81,3,81,1409,8,81,1,81,3,81,1412,8,81,1,81,1,81,1,
  	82,1,82,3,82,1418,8,82,1,82,1,82,3,82,1422,8,82,1,82,1,82,3,82,1426,8,
  	82,3,82,1428,8,82,1,82,1,82,3,82,1432,8,82,1,82,1,82,3,82,1436,8,82,1,
  	82,1,82,3,82,1440,8,82,3,82,1442,8,82,1,82,1,82,3,82,1446,8,82,1,82,1,
  	82,3,82,1450,8,82,1,82,1,82,1,83,1,83,3,83,1456,8,83,1,83,1,83,1,84,1,
  	84,3,84,1462,8,84,1,84,4,84,1465,8,84,11,84,12,84,1466,1,84,1,84,3,84,
  	1471,8,84,1,84,1,84,3,84,1475,8,84,1,84,4,84,1478,8,84,11,84,12,84,1479,
  	3,84,1482,8,84,1,84,3,84,1485,8,84,1,84,1,84,3,84,1489,8,84,1,84,3,84,
  	1492,8,84,1,84,3,84,1495,8,84,1,84,1,84,1,85,1,85,3,85,1501,8,85,1,85,
  	1,85,3,85,1505,8,85,1,85,1,85,3,85,1509,8,85,1,85,1,85,1,86,1,86,1,87,
  	1,87,3,87,1517,8,87,1,88,1,88,3,88,1521,8,88,1,88,1,88,3,88,1525,8,88,
  	1,88,1,88,3,88,1529,8,88,1,88,1,88,3,88,1533,8,88,1,88,1,88,3,88,1537,
  	8,88,1,88,1,88,3,88,1541,8,88,1,88,1,88,3,88,1545,8,88,1,88,1,88,3,88,
  	1549,8,88,5,88,1551,8,88,10,88,12,88,1554,9,88,3,88,1556,8,88,1,88,1,
  	88,1,89,1,89,1,89,3,89,1563,8,89,1,90,1,90,3,90,1567,8,90,1,90,4,90,1570,
  	8,90,11,90,12,90,1571,1,91,1,91,1,92,1,92,1,93,1,93,1,94,1,94,3,94,1582,
  	8,94,1,95,1,95,1,96,1,96,1,97,1,97,1,98,1,98,1,99,1,99,1,99,0,0,100,0,
  	2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,
  	52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,
  	98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,
  	134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,
  	170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,0,10,1,0,
  	70,73,1,0,13,14,1,0,93,94,1,0,103,105,1,0,113,114,4,0,89,92,106,106,115,
  	117,130,130,6,0,48,60,63,73,77,85,87,88,93,100,118,127,2,0,19,19,27,30,
  	2,0,20,20,31,34,2,0,14,14,35,45,1820,0,201,1,0,0,0,2,226,1,0,0,0,4,230,
  	1,0,0,0,6,232,1,0,0,0,8,254,1,0,0,0,10,258,1,0,0,0,12,295,1,0,0,0,14,
  	319,1,0,0,0,16,330,1,0,0,0,18,335,1,0,0,0,20,339,1,0,0,0,22,361,1,0,0,
  	0,24,371,1,0,0,0,26,393,1,0,0,0,28,395,1,0,0,0,30,401,1,0,0,0,32,455,
  	1,0,0,0,34,459,1,0,0,0,36,479,1,0,0,0,38,499,1,0,0,0,40,501,1,0,0,0,42,
  	512,1,0,0,0,44,539,1,0,0,0,46,552,1,0,0,0,48,556,1,0,0,0,50,571,1,0,0,
  	0,52,581,1,0,0,0,54,622,1,0,0,0,56,631,1,0,0,0,58,633,1,0,0,0,60,648,
  	1,0,0,0,62,652,1,0,0,0,64,656,1,0,0,0,66,677,1,0,0,0,68,679,1,0,0,0,70,
  	683,1,0,0,0,72,708,1,0,0,0,74,710,1,0,0,0,76,726,1,0,0,0,78,728,1,0,0,
  	0,80,752,1,0,0,0,82,822,1,0,0,0,84,824,1,0,0,0,86,853,1,0,0,0,88,855,
  	1,0,0,0,90,876,1,0,0,0,92,886,1,0,0,0,94,892,1,0,0,0,96,914,1,0,0,0,98,
  	916,1,0,0,0,100,918,1,0,0,0,102,920,1,0,0,0,104,930,1,0,0,0,106,940,1,
  	0,0,0,108,956,1,0,0,0,110,961,1,0,0,0,112,971,1,0,0,0,114,993,1,0,0,0,
  	116,1023,1,0,0,0,118,1043,1,0,0,0,120,1048,1,0,0,0,122,1082,1,0,0,0,124,
  	1096,1,0,0,0,126,1113,1,0,0,0,128,1115,1,0,0,0,130,1209,1,0,0,0,132,1217,
  	1,0,0,0,134,1219,1,0,0,0,136,1221,1,0,0,0,138,1276,1,0,0,0,140,1278,1,
  	0,0,0,142,1288,1,0,0,0,144,1297,1,0,0,0,146,1304,1,0,0,0,148,1310,1,0,
  	0,0,150,1349,1,0,0,0,152,1351,1,0,0,0,154,1380,1,0,0,0,156,1382,1,0,0,
  	0,158,1384,1,0,0,0,160,1392,1,0,0,0,162,1395,1,0,0,0,164,1415,1,0,0,0,
  	166,1453,1,0,0,0,168,1481,1,0,0,0,170,1498,1,0,0,0,172,1512,1,0,0,0,174,
  	1516,1,0,0,0,176,1518,1,0,0,0,178,1559,1,0,0,0,180,1564,1,0,0,0,182,1573,
  	1,0,0,0,184,1575,1,0,0,0,186,1577,1,0,0,0,188,1581,1,0,0,0,190,1583,1,
  	0,0,0,192,1585,1,0,0,0,194,1587,1,0,0,0,196,1589,1,0,0,0,198,1591,1,0,
  	0,0,200,202,5,131,0,0,201,200,1,0,0,0,201,202,1,0,0,0,202,203,1,0,0,0,
  	203,208,3,2,1,0,204,206,5,131,0,0,205,204,1,0,0,0,205,206,1,0,0,0,206,
  	207,1,0,0,0,207,209,5,1,0,0,208,205,1,0,0,0,208,209,1,0,0,0,209,211,1,
  	0,0,0,210,212,5,131,0,0,211,210,1,0,0,0,211,212,1,0,0,0,212,213,1,0,0,
  	0,213,214,5,0,0,1,214,1,1,0,0,0,215,227,3,4,2,0,216,218,5,46,0,0,217,
  	219,5,131,0,0,218,217,1,0,0,0,218,219,1,0,0,0,219,220,1,0,0,0,220,227,
  	3,4,2,0,221,223,5,47,0,0,222,224,5,131,0,0,223,222,1,0,0,0,223,224,1,
  	0,0,0,224,225,1,0,0,0,225,227,3,4,2,0,226,215,1,0,0,0,226,216,1,0,0,0,
  	226,221,1,0,0,0,227,3,1,0,0,0,228,231,3,6,3,0,229,231,3,42,21,0,230,228,
  	1,0,0,0,230,229,1,0,0,0,231,5,1,0,0,0,232,239,3,10,5,0,233,235,5,131,
  	0,0,234,233,1,0,0,0,234,235,1,0,0,0,235,236,1,0,0,0,236,238,3,8,4,0,237,
  	234,1,0,0,0,238,241,1,0,0,0,239,237,1,0,0,0,239,240,1,0,0,0,240,7,1,0,
  	0,0,241,239,1,0,0,0,242,243,5,48,0,0,243,244,5,131,0,0,244,246,5,49,0,
  	0,245,247,5,131,0,0,246,245,1,0,0,0,246,247,1,0,0,0,247,248,1,0,0,0,248,
  	255,3,10,5,0,249,251,5,48,0,0,250,252,5,131,0,0,251,250,1,0,0,0,251,252,
  	1,0,0,0,252,253,1,0,0,0,253,255,3,10,5,0,254,242,1,0,0,0,254,249,1,0,
  	0,0,255,9,1,0,0,0,256,259,3,12,6,0,257,259,3,14,7,0,258,256,1,0,0,0,258,
  	257,1,0,0,0,259,11,1,0,0,0,260,262,3,18,9,0,261,263,5,131,0,0,262,261,
  	1,0,0,0,262,263,1,0,0,0,263,265,1,0,0,0,264,260,1,0,0,0,265,268,1,0,0,
  	0,266,264,1,0,0,0,266,267,1,0,0,0,267,269,1,0,0,0,268,266,1,0,0,0,269,
  	296,3,50,25,0,270,272,3,18,9,0,271,273,5,131,0,0,272,271,1,0,0,0,272,
  	273,1,0,0,0,273,275,1,0,0,0,274,270,1,0,0,0,275,278,1,0,0,0,276,274,1,
  	0,0,0,276,277,1,0,0,0,277,279,1,0,0,0,278,276,1,0,0,0,279,286,3,16,8,
  	0,280,282,5,131,0,0,281,280,1,0,0,0,281,282,1,0,0,0,282,283,1,0,0,0,283,
  	285,3,16,8,0,284,281,1,0,0,0,285,288,1,0,0,0,286,284,1,0,0,0,286,287,
  	1,0,0,0,287,293,1,0,0,0,288,286,1,0,0,0,289,291,5,131,0,0,290,289,1,0,
  	0,0,290,291,1,0,0,0,291,292,1,0,0,0,292,294,3,50,25,0,293,290,1,0,0,0,
  	293,294,1,0,0,0,294,296,1,0,0,0,295,266,1,0,0,0,295,276,1,0,0,0,296,13,
  	1,0,0,0,297,299,3,18,9,0,298,300,5,131,0,0,299,298,1,0,0,0,299,300,1,
  	0,0,0,300,302,1,0,0,0,301,297,1,0,0,0,302,305,1,0,0,0,303,301,1,0,0,0,
  	303,304,1,0,0,0,304,312,1,0,0,0,305,303,1,0,0,0,306,308,3,16,8,0,307,
  	309,5,131,0,0,308,307,1,0,0,0,308,309,1,0,0,0,309,311,1,0,0,0,310,306,
  	1,0,0,0,311,314,1,0,0,0,312,310,1,0,0,0,312,313,1,0,0,0,313,315,1,0,0,
  	0,314,312,1,0,0,0,315,317,3,48,24,0,316,318,5,131,0,0,317,316,1,0,0,0,
  	317,318,1,0,0,0,318,320,1,0,0,0,319,303,1,0,0,0,320,321,1,0,0,0,321,319,
  	1,0,0,0,321,322,1,0,0,0,322,323,1,0,0,0,323,324,3,12,6,0,324,15,1,0,0,
  	0,325,331,3,28,14,0,326,331,3,24,12,0,327,331,3,34,17,0,328,331,3,30,
  	15,0,329,331,3,36,18,0,330,325,1,0,0,0,330,326,1,0,0,0,330,327,1,0,0,
  	0,330,328,1,0,0,0,330,329,1,0,0,0,331,17,1,0,0,0,332,336,3,20,10,0,333,
  	336,3,22,11,0,334,336,3,40,20,0,335,332,1,0,0,0,335,333,1,0,0,0,335,334,
  	1,0,0,0,336,19,1,0,0,0,337,338,5,50,0,0,338,340,5,131,0,0,339,337,1,0,
  	0,0,339,340,1,0,0,0,340,341,1,0,0,0,341,343,5,51,0,0,342,344,5,131,0,
  	0,343,342,1,0,0,0,343,344,1,0,0,0,344,345,1,0,0,0,345,352,3,70,35,0,346,
  	348,5,131,0,0,347,346,1,0,0,0,347,348,1,0,0,0,348,349,1,0,0,0,349,351,
  	3,66,33,0,350,347,1,0,0,0,351,354,1,0,0,0,352,350,1,0,0,0,352,353,1,0,
  	0,0,353,359,1,0,0,0,354,352,1,0,0,0,355,357,5,131,0,0,356,355,1,0,0,0,
  	356,357,1,0,0,0,357,358,1,0,0,0,358,360,3,68,34,0,359,356,1,0,0,0,359,
  	360,1,0,0,0,360,21,1,0,0,0,361,363,5,52,0,0,362,364,5,131,0,0,363,362,
  	1,0,0,0,363,364,1,0,0,0,364,365,1,0,0,0,365,366,3,100,50,0,366,367,5,
  	131,0,0,367,368,5,53,0,0,368,369,5,131,0,0,369,370,3,172,86,0,370,23,
  	1,0,0,0,371,373,5,54,0,0,372,374,5,131,0,0,373,372,1,0,0,0,373,374,1,
  	0,0,0,374,375,1,0,0,0,375,380,3,72,36,0,376,377,5,131,0,0,377,379,3,26,
  	13,0,378,376,1,0,0,0,379,382,1,0,0,0,380,378,1,0,0,0,380,381,1,0,0,0,
  	381,25,1,0,0,0,382,380,1,0,0,0,383,384,5,55,0,0,384,385,5,131,0,0,385,
  	386,5,51,0,0,386,387,5,131,0,0,387,394,3,30,15,0,388,389,5,55,0,0,389,
  	390,5,131,0,0,390,391,5,56,0,0,391,392,5,131,0,0,392,394,3,30,15,0,393,
  	383,1,0,0,0,393,388,1,0,0,0,394,27,1,0,0,0,395,397,5,56,0,0,396,398,5,
  	131,0,0,397,396,1,0,0,0,397,398,1,0,0,0,398,399,1,0,0,0,399,400,3,70,
  	35,0,400,29,1,0,0,0,401,403,5,57,0,0,402,404,5,131,0,0,403,402,1,0,0,
  	0,403,404,1,0,0,0,404,405,1,0,0,0,405,416,3,32,16,0,406,408,5,131,0,0,
  	407,406,1,0,0,0,407,408,1,0,0,0,408,409,1,0,0,0,409,411,5,2,0,0,410,412,
  	5,131,0,0,411,410,1,0,0,0,411,412,1,0,0,0,412,413,1,0,0,0,413,415,3,32,
  	16,0,414,407,1,0,0,0,415,418,1,0,0,0,416,414,1,0,0,0,416,417,1,0,0,0,
  	417,31,1,0,0,0,418,416,1,0,0,0,419,421,3,180,90,0,420,422,5,131,0,0,421,
  	420,1,0,0,0,421,422,1,0,0,0,422,423,1,0,0,0,423,425,5,3,0,0,424,426,5,
  	131,0,0,425,424,1,0,0,0,425,426,1,0,0,0,426,427,1,0,0,0,427,428,3,100,
  	50,0,428,456,1,0,0,0,429,431,3,172,86,0,430,432,5,131,0,0,431,430,1,0,
  	0,0,431,432,1,0,0,0,432,433,1,0,0,0,433,435,5,3,0,0,434,436,5,131,0,0,
  	435,434,1,0,0,0,435,436,1,0,0,0,436,437,1,0,0,0,437,438,3,100,50,0,438,
  	456,1,0,0,0,439,441,3,172,86,0,440,442,5,131,0,0,441,440,1,0,0,0,441,
  	442,1,0,0,0,442,443,1,0,0,0,443,445,5,4,0,0,444,446,5,131,0,0,445,444,
  	1,0,0,0,445,446,1,0,0,0,446,447,1,0,0,0,447,448,3,100,50,0,448,456,1,
  	0,0,0,449,451,3,172,86,0,450,452,5,131,0,0,451,450,1,0,0,0,451,452,1,
  	0,0,0,452,453,1,0,0,0,453,454,3,90,45,0,454,456,1,0,0,0,455,419,1,0,0,
  	0,455,429,1,0,0,0,455,439,1,0,0,0,455,449,1,0,0,0,456,33,1,0,0,0,457,
  	458,5,58,0,0,458,460,5,131,0,0,459,457,1,0,0,0,459,460,1,0,0,0,460,461,
  	1,0,0,0,461,463,5,59,0,0,462,464,5,131,0,0,463,462,1,0,0,0,463,464,1,
  	0,0,0,464,465,1,0,0,0,465,476,3,100,50,0,466,468,5,131,0,0,467,466,1,
  	0,0,0,467,468,1,0,0,0,468,469,1,0,0,0,469,471,5,2,0,0,470,472,5,131,0,
  	0,471,470,1,0,0,0,471,472,1,0,0,0,472,473,1,0,0,0,473,475,3,100,50,0,
  	474,467,1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0,0,477,35,
  	1,0,0,0,478,476,1,0,0,0,479,480,5,60,0,0,480,481,5,131,0,0,481,492,3,
  	38,19,0,482,484,5,131,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,485,1,0,
  	0,0,485,487,5,2,0,0,486,488,5,131,0,0,487,486,1,0,0,0,487,488,1,0,0,0,
  	488,489,1,0,0,0,489,491,3,38,19,0,490,483,1,0,0,0,491,494,1,0,0,0,492,
  	490,1,0,0,0,492,493,1,0,0,0,493,37,1,0,0,0,494,492,1,0,0,0,495,496,3,
  	172,86,0,496,497,3,90,45,0,497,500,1,0,0,0,498,500,3,180,90,0,499,495,
  	1,0,0,0,499,498,1,0,0,0,500,39,1,0,0,0,501,502,5,61,0,0,502,503,5,131,
  	0,0,503,510,3,152,76,0,504,506,5,131,0,0,505,504,1,0,0,0,505,506,1,0,
  	0,0,506,507,1,0,0,0,507,508,5,62,0,0,508,509,5,131,0,0,509,511,3,44,22,
  	0,510,505,1,0,0,0,510,511,1,0,0,0,511,41,1,0,0,0,512,513,5,61,0,0,513,
  	516,5,131,0,0,514,517,3,152,76,0,515,517,3,154,77,0,516,514,1,0,0,0,516,
  	515,1,0,0,0,517,522,1,0,0,0,518,519,5,131,0,0,519,520,5,62,0,0,520,521,
  	5,131,0,0,521,523,3,44,22,0,522,518,1,0,0,0,522,523,1,0,0,0,523,43,1,
  	0,0,0,524,540,5,5,0,0,525,536,3,46,23,0,526,528,5,131,0,0,527,526,1,0,
  	0,0,527,528,1,0,0,0,528,529,1,0,0,0,529,531,5,2,0,0,530,532,5,131,0,0,
  	531,530,1,0,0,0,531,532,1,0,0,0,532,533,1,0,0,0,533,535,3,46,23,0,534,
  	527,1,0,0,0,535,538,1,0,0,0,536,534,1,0,0,0,536,537,1,0,0,0,537,540,1,
  	0,0,0,538,536,1,0,0,0,539,524,1,0,0,0,539,525,1,0,0,0,540,545,1,0,0,0,
  	541,543,5,131,0,0,542,541,1,0,0,0,542,543,1,0,0,0,543,544,1,0,0,0,544,
  	546,3,68,34,0,545,542,1,0,0,0,545,546,1,0,0,0,546,45,1,0,0,0,547,548,
  	3,156,78,0,548,549,5,131,0,0,549,550,5,53,0,0,550,551,5,131,0,0,551,553,
  	1,0,0,0,552,547,1,0,0,0,552,553,1,0,0,0,553,554,1,0,0,0,554,555,3,172,
  	86,0,555,47,1,0,0,0,556,561,5,63,0,0,557,559,5,131,0,0,558,557,1,0,0,
  	0,558,559,1,0,0,0,559,560,1,0,0,0,560,562,5,64,0,0,561,558,1,0,0,0,561,
  	562,1,0,0,0,562,563,1,0,0,0,563,564,5,131,0,0,564,569,3,52,26,0,565,567,
  	5,131,0,0,566,565,1,0,0,0,566,567,1,0,0,0,567,568,1,0,0,0,568,570,3,68,
  	34,0,569,566,1,0,0,0,569,570,1,0,0,0,570,49,1,0,0,0,571,576,5,65,0,0,
  	572,574,5,131,0,0,573,572,1,0,0,0,573,574,1,0,0,0,574,575,1,0,0,0,575,
  	577,5,64,0,0,576,573,1,0,0,0,576,577,1,0,0,0,577,578,1,0,0,0,578,579,
  	5,131,0,0,579,580,3,52,26,0,580,51,1,0,0,0,581,584,3,54,27,0,582,583,
  	5,131,0,0,583,585,3,58,29,0,584,582,1,0,0,0,584,585,1,0,0,0,585,588,1,
  	0,0,0,586,587,5,131,0,0,587,589,3,60,30,0,588,586,1,0,0,0,588,589,1,0,
  	0,0,589,592,1,0,0,0,590,591,5,131,0,0,591,593,3,62,31,0,592,590,1,0,0,
  	0,592,593,1,0,0,0,593,53,1,0,0,0,594,605,5,5,0,0,595,597,5,131,0,0,596,
  	595,1,0,0,0,596,597,1,0,0,0,597,598,1,0,0,0,598,600,5,2,0,0,599,601,5,
  	131,0,0,600,599,1,0,0,0,600,601,1,0,0,0,601,602,1,0,0,0,602,604,3,56,
  	28,0,603,596,1,0,0,0,604,607,1,0,0,0,605,603,1,0,0,0,605,606,1,0,0,0,
  	606,623,1,0,0,0,607,605,1,0,0,0,608,619,3,56,28,0,609,611,5,131,0,0,610,
  	609,1,0,0,0,610,611,1,0,0,0,611,612,1,0,0,0,612,614,5,2,0,0,613,615,5,
  	131,0,0,614,613,1,0,0,0,614,615,1,0,0,0,615,616,1,0,0,0,616,618,3,56,
  	28,0,617,610,1,0,0,0,618,621,1,0,0,0,619,617,1,0,0,0,619,620,1,0,0,0,
  	620,623,1,0,0,0,621,619,1,0,0,0,622,594,1,0,0,0,622,608,1,0,0,0,623,55,
  	1,0,0,0,624,625,3,100,50,0,625,626,5,131,0,0,626,627,5,53,0,0,627,628,
  	5,131,0,0,628,629,3,172,86,0,629,632,1,0,0,0,630,632,3,100,50,0,631,624,
  	1,0,0,0,631,630,1,0,0,0,632,57,1,0,0,0,633,634,5,66,0,0,634,635,5,131,
  	0,0,635,636,5,67,0,0,636,637,5,131,0,0,637,645,3,64,32,0,638,640,5,2,
  	0,0,639,641,5,131,0,0,640,639,1,0,0,0,640,641,1,0,0,0,641,642,1,0,0,0,
  	642,644,3,64,32,0,643,638,1,0,0,0,644,647,1,0,0,0,645,643,1,0,0,0,645,
  	646,1,0,0,0,646,59,1,0,0,0,647,645,1,0,0,0,648,649,5,68,0,0,649,650,5,
  	131,0,0,650,651,3,100,50,0,651,61,1,0,0,0,652,653,5,69,0,0,653,654,5,
  	131,0,0,654,655,3,100,50,0,655,63,1,0,0,0,656,661,3,100,50,0,657,659,
  	5,131,0,0,658,657,1,0,0,0,658,659,1,0,0,0,659,660,1,0,0,0,660,662,7,0,
  	0,0,661,658,1,0,0,0,661,662,1,0,0,0,662,65,1,0,0,0,663,664,5,74,0,0,664,
  	665,5,131,0,0,665,666,5,75,0,0,666,667,5,131,0,0,667,668,5,55,0,0,668,
  	669,5,131,0,0,669,678,3,172,86,0,670,671,5,74,0,0,671,672,5,131,0,0,672,
  	673,5,76,0,0,673,674,5,131,0,0,674,675,5,55,0,0,675,676,5,131,0,0,676,
  	678,3,172,86,0,677,663,1,0,0,0,677,670,1,0,0,0,678,67,1,0,0,0,679,680,
  	5,77,0,0,680,681,5,131,0,0,681,682,3,100,50,0,682,69,1,0,0,0,683,694,
  	3,72,36,0,684,686,5,131,0,0,685,684,1,0,0,0,685,686,1,0,0,0,686,687,1,
  	0,0,0,687,689,5,2,0,0,688,690,5,131,0,0,689,688,1,0,0,0,689,690,1,0,0,
  	0,690,691,1,0,0,0,691,693,3,72,36,0,692,685,1,0,0,0,693,696,1,0,0,0,694,
  	692,1,0,0,0,694,695,1,0,0,0,695,71,1,0,0,0,696,694,1,0,0,0,697,699,3,
  	172,86,0,698,700,5,131,0,0,699,698,1,0,0,0,699,700,1,0,0,0,700,701,1,
  	0,0,0,701,703,5,3,0,0,702,704,5,131,0,0,703,702,1,0,0,0,703,704,1,0,0,
  	0,704,705,1,0,0,0,705,706,3,74,37,0,706,709,1,0,0,0,707,709,3,74,37,0,
  	708,697,1,0,0,0,708,707,1,0,0,0,709,73,1,0,0,0,710,711,3,76,38,0,711,
  	75,1,0,0,0,712,719,3,78,39,0,713,715,5,131,0,0,714,713,1,0,0,0,714,715,
  	1,0,0,0,715,716,1,0,0,0,716,718,3,80,40,0,717,714,1,0,0,0,718,721,1,0,
  	0,0,719,717,1,0,0,0,719,720,1,0,0,0,720,727,1,0,0,0,721,719,1,0,0,0,722,
  	723,5,6,0,0,723,724,3,76,38,0,724,725,5,7,0,0,725,727,1,0,0,0,726,712,
  	1,0,0,0,726,722,1,0,0,0,727,77,1,0,0,0,728,730,5,6,0,0,729,731,5,131,
  	0,0,730,729,1,0,0,0,730,731,1,0,0,0,731,736,1,0,0,0,732,734,3,172,86,
  	0,733,735,5,131,0,0,734,733,1,0,0,0,734,735,1,0,0,0,735,737,1,0,0,0,736,
  	732,1,0,0,0,736,737,1,0,0,0,737,742,1,0,0,0,738,740,3,90,45,0,739,741,
  	5,131,0,0,740,739,1,0,0,0,740,741,1,0,0,0,741,743,1,0,0,0,742,738,1,0,
  	0,0,742,743,1,0,0,0,743,748,1,0,0,0,744,746,3,86,43,0,745,747,5,131,0,
  	0,746,745,1,0,0,0,746,747,1,0,0,0,747,749,1,0,0,0,748,744,1,0,0,0,748,
  	749,1,0,0,0,749,750,1,0,0,0,750,751,5,7,0,0,751,79,1,0,0,0,752,754,3,
  	82,41,0,753,755,5,131,0,0,754,753,1,0,0,0,754,755,1,0,0,0,755,756,1,0,
  	0,0,756,757,3,78,39,0,757,81,1,0,0,0,758,760,3,194,97,0,759,761,5,131,
  	0,0,760,759,1,0,0,0,760,761,1,0,0,0,761,762,1,0,0,0,762,764,3,198,99,
  	0,763,765,5,131,0,0,764,763,1,0,0,0,764,765,1,0,0,0,765,767,1,0,0,0,766,
  	768,3,84,42,0,767,766,1,0,0,0,767,768,1,0,0,0,768,770,1,0,0,0,769,771,
  	5,131,0,0,770,769,1,0,0,0,770,771,1,0,0,0,771,772,1,0,0,0,772,774,3,198,
  	99,0,773,775,5,131,0,0,774,773,1,0,0,0,774,775,1,0,0,0,775,776,1,0,0,
  	0,776,777,3,196,98,0,777,823,1,0,0,0,778,780,3,194,97,0,779,781,5,131,
  	0,0,780,779,1,0,0,0,780,781,1,0,0,0,781,782,1,0,0,0,782,784,3,198,99,
  	0,783,785,5,131,0,0,784,783,1,0,0,0,784,785,1,0,0,0,785,787,1,0,0,0,786,
  	788,3,84,42,0,787,786,1,0,0,0,787,788,1,0,0,0,788,790,1,0,0,0,789,791,
  	5,131,0,0,790,789,1,0,0,0,790,791,1,0,0,0,791,792,1,0,0,0,792,793,3,198,
  	99,0,793,823,1,0,0,0,794,796,3,198,99,0,795,797,5,131,0,0,796,795,1,0,
  	0,0,796,797,1,0,0,0,797,799,1,0,0,0,798,800,3,84,42,0,799,798,1,0,0,0,
  	799,800,1,0,0,0,800,802,1,0,0,0,801,803,5,131,0,0,802,801,1,0,0,0,802,
  	803,1,0,0,0,803,804,1,0,0,0,804,806,3,198,99,0,805,807,5,131,0,0,806,
  	805,1,0,0,0,806,807,1,0,0,0,807,808,1,0,0,0,808,809,3,196,98,0,809,823,
  	1,0,0,0,810,812,3,198,99,0,811,813,5,131,0,0,812,811,1,0,0,0,812,813,
  	1,0,0,0,813,815,1,0,0,0,814,816,3,84,42,0,815,814,1,0,0,0,815,816,1,0,
  	0,0,816,818,1,0,0,0,817,819,5,131,0,0,818,817,1,0,0,0,818,819,1,0,0,0,
  	819,820,1,0,0,0,820,821,3,198,99,0,821,823,1,0,0,0,822,758,1,0,0,0,822,
  	778,1,0,0,0,822,794,1,0,0,0,822,810,1,0,0,0,823,83,1,0,0,0,824,826,5,
  	8,0,0,825,827,5,131,0,0,826,825,1,0,0,0,826,827,1,0,0,0,827,832,1,0,0,
  	0,828,830,3,172,86,0,829,831,5,131,0,0,830,829,1,0,0,0,830,831,1,0,0,
  	0,831,833,1,0,0,0,832,828,1,0,0,0,832,833,1,0,0,0,833,838,1,0,0,0,834,
  	836,3,88,44,0,835,837,5,131,0,0,836,835,1,0,0,0,836,837,1,0,0,0,837,839,
  	1,0,0,0,838,834,1,0,0,0,838,839,1,0,0,0,839,841,1,0,0,0,840,842,3,94,
  	47,0,841,840,1,0,0,0,841,842,1,0,0,0,842,847,1,0,0,0,843,845,3,86,43,
  	0,844,846,5,131,0,0,845,844,1,0,0,0,845,846,1,0,0,0,846,848,1,0,0,0,847,
  	843,1,0,0,0,847,848,1,0,0,0,848,849,1,0,0,0,849,850,5,9,0,0,850,85,1,
  	0,0,0,851,854,3,176,88,0,852,854,3,178,89,0,853,851,1,0,0,0,853,852,1,
  	0,0,0,854,87,1,0,0,0,855,857,5,10,0,0,856,858,5,131,0,0,857,856,1,0,0,
  	0,857,858,1,0,0,0,858,859,1,0,0,0,859,873,3,98,49,0,860,862,5,131,0,0,
  	861,860,1,0,0,0,861,862,1,0,0,0,862,863,1,0,0,0,863,865,5,11,0,0,864,
  	866,5,10,0,0,865,864,1,0,0,0,865,866,1,0,0,0,866,868,1,0,0,0,867,869,
  	5,131,0,0,868,867,1,0,0,0,868,869,1,0,0,0,869,870,1,0,0,0,870,872,3,98,
  	49,0,871,861,1,0,0,0,872,875,1,0,0,0,873,871,1,0,0,0,873,874,1,0,0,0,
  	874,89,1,0,0,0,875,873,1,0,0,0,876,883,3,92,46,0,877,879,5,131,0,0,878,
  	877,1,0,0,0,878,879,1,0,0,0,879,880,1,0,0,0,880,882,3,92,46,0,881,878,
  	1,0,0,0,882,885,1,0,0,0,883,881,1,0,0,0,883,884,1,0,0,0,884,91,1,0,0,
  	0,885,883,1,0,0,0,886,888,5,10,0,0,887,889,5,131,0,0,888,887,1,0,0,0,
  	888,889,1,0,0,0,889,890,1,0,0,0,890,891,3,96,48,0,891,93,1,0,0,0,892,
  	894,5,5,0,0,893,895,5,131,0,0,894,893,1,0,0,0,894,895,1,0,0,0,895,900,
  	1,0,0,0,896,898,3,184,92,0,897,899,5,131,0,0,898,897,1,0,0,0,898,899,
  	1,0,0,0,899,901,1,0,0,0,900,896,1,0,0,0,900,901,1,0,0,0,901,912,1,0,0,
  	0,902,904,5,12,0,0,903,905,5,131,0,0,904,903,1,0,0,0,904,905,1,0,0,0,
  	905,910,1,0,0,0,906,908,3,184,92,0,907,909,5,131,0,0,908,907,1,0,0,0,
  	908,909,1,0,0,0,909,911,1,0,0,0,910,906,1,0,0,0,910,911,1,0,0,0,911,913,
  	1,0,0,0,912,902,1,0,0,0,912,913,1,0,0,0,913,95,1,0,0,0,914,915,3,188,
  	94,0,915,97,1,0,0,0,916,917,3,188,94,0,917,99,1,0,0,0,918,919,3,102,51,
  	0,919,101,1,0,0,0,920,927,3,104,52,0,921,922,5,131,0,0,922,923,5,78,0,
  	0,923,924,5,131,0,0,924,926,3,104,52,0,925,921,1,0,0,0,926,929,1,0,0,
  	0,927,925,1,0,0,0,927,928,1,0,0,0,928,103,1,0,0,0,929,927,1,0,0,0,930,
  	937,3,106,53,0,931,932,5,131,0,0,932,933,5,79,0,0,933,934,5,131,0,0,934,
  	936,3,106,53,0,935,931,1,0,0,0,936,939,1,0,0,0,937,935,1,0,0,0,937,938,
  	1,0,0,0,938,105,1,0,0,0,939,937,1,0,0,0,940,947,3,108,54,0,941,942,5,
  	131,0,0,942,943,5,80,0,0,943,944,5,131,0,0,944,946,3,108,54,0,945,941,
  	1,0,0,0,946,949,1,0,0,0,947,945,1,0,0,0,947,948,1,0,0,0,948,107,1,0,0,
  	0,949,947,1,0,0,0,950,952,5,81,0,0,951,953,5,131,0,0,952,951,1,0,0,0,
  	952,953,1,0,0,0,953,955,1,0,0,0,954,950,1,0,0,0,955,958,1,0,0,0,956,954,
  	1,0,0,0,956,957,1,0,0,0,957,959,1,0,0,0,958,956,1,0,0,0,959,960,3,110,
  	55,0,960,109,1,0,0,0,961,968,3,112,56,0,962,964,5,131,0,0,963,962,1,0,
  	0,0,963,964,1,0,0,0,964,965,1,0,0,0,965,967,3,138,69,0,966,963,1,0,0,
  	0,967,970,1,0,0,0,968,966,1,0,0,0,968,969,1,0,0,0,969,111,1,0,0,0,970,
  	968,1,0,0,0,971,990,3,114,57,0,972,974,5,131,0,0,973,972,1,0,0,0,973,
  	974,1,0,0,0,974,975,1,0,0,0,975,977,5,13,0,0,976,978,5,131,0,0,977,976,
  	1,0,0,0,977,978,1,0,0,0,978,979,1,0,0,0,979,989,3,114,57,0,980,982,5,
  	131,0,0,981,980,1,0,0,0,981,982,1,0,0,0,982,983,1,0,0,0,983,985,5,14,
  	0,0,984,986,5,131,0,0,985,984,1,0,0,0,985,986,1,0,0,0,986,987,1,0,0,0,
  	987,989,3,114,57,0,988,973,1,0,0,0,988,981,1,0,0,0,989,992,1,0,0,0,990,
  	988,1,0,0,0,990,991,1,0,0,0,991,113,1,0,0,0,992,990,1,0,0,0,993,1020,
  	3,116,58,0,994,996,5,131,0,0,995,994,1,0,0,0,995,996,1,0,0,0,996,997,
  	1,0,0,0,997,999,5,5,0,0,998,1000,5,131,0,0,999,998,1,0,0,0,999,1000,1,
  	0,0,0,1000,1001,1,0,0,0,1001,1019,3,116,58,0,1002,1004,5,131,0,0,1003,
  	1002,1,0,0,0,1003,1004,1,0,0,0,1004,1005,1,0,0,0,1005,1007,5,15,0,0,1006,
  	1008,5,131,0,0,1007,1006,1,0,0,0,1007,1008,1,0,0,0,1008,1009,1,0,0,0,
  	1009,1019,3,116,58,0,1010,1012,5,131,0,0,1011,1010,1,0,0,0,1011,1012,
  	1,0,0,0,1012,1013,1,0,0,0,1013,1015,5,16,0,0,1014,1016,5,131,0,0,1015,
  	1014,1,0,0,0,1015,1016,1,0,0,0,1016,1017,1,0,0,0,1017,1019,3,116,58,0,
  	1018,995,1,0,0,0,1018,1003,1,0,0,0,1018,1011,1,0,0,0,1019,1022,1,0,0,
  	0,1020,1018,1,0,0,0,1020,1021,1,0,0,0,1021,115,1,0,0,0,1022,1020,1,0,
  	0,0,1023,1034,3,118,59,0,1024,1026,5,131,0,0,1025,1024,1,0,0,0,1025,1026,
  	1,0,0,0,1026,1027,1,0,0,0,1027,1029,5,17,0,0,1028,1030,5,131,0,0,1029,
  	1028,1,0,0,0,1029,1030,1,0,0,0,1030,1031,1,0,0,0,1031,1033,3,118,59,0,
  	1032,1025,1,0,0,0,1033,1036,1,0,0,0,1034,1032,1,0,0,0,1034,1035,1,0,0,
  	0,1035,117,1,0,0,0,1036,1034,1,0,0,0,1037,1039,7,1,0,0,1038,1040,5,131,
  	0,0,1039,1038,1,0,0,0,1039,1040,1,0,0,0,1040,1042,1,0,0,0,1041,1037,1,
  	0,0,0,1042,1045,1,0,0,0,1043,1041,1,0,0,0,1043,1044,1,0,0,0,1044,1046,
  	1,0,0,0,1045,1043,1,0,0,0,1046,1047,3,120,60,0,1047,119,1,0,0,0,1048,
  	1054,3,128,64,0,1049,1053,3,124,62,0,1050,1053,3,122,61,0,1051,1053,3,
  	126,63,0,1052,1049,1,0,0,0,1052,1050,1,0,0,0,1052,1051,1,0,0,0,1053,1056,
  	1,0,0,0,1054,1052,1,0,0,0,1054,1055,1,0,0,0,1055,121,1,0,0,0,1056,1054,
  	1,0,0,0,1057,1058,5,131,0,0,1058,1060,5,82,0,0,1059,1061,5,131,0,0,1060,
  	1059,1,0,0,0,1060,1061,1,0,0,0,1061,1062,1,0,0,0,1062,1083,3,128,64,0,
  	1063,1065,5,131,0,0,1064,1063,1,0,0,0,1064,1065,1,0,0,0,1065,1066,1,0,
  	0,0,1066,1067,5,8,0,0,1067,1068,3,100,50,0,1068,1069,5,9,0,0,1069,1083,
  	1,0,0,0,1070,1072,5,131,0,0,1071,1070,1,0,0,0,1071,1072,1,0,0,0,1072,
  	1073,1,0,0,0,1073,1075,5,8,0,0,1074,1076,3,100,50,0,1075,1074,1,0,0,0,
  	1075,1076,1,0,0,0,1076,1077,1,0,0,0,1077,1079,5,12,0,0,1078,1080,3,100,
  	50,0,1079,1078,1,0,0,0,1079,1080,1,0,0,0,1080,1081,1,0,0,0,1081,1083,
  	5,9,0,0,1082,1057,1,0,0,0,1082,1064,1,0,0,0,1082,1071,1,0,0,0,1083,123,
  	1,0,0,0,1084,1085,5,131,0,0,1085,1086,5,83,0,0,1086,1087,5,131,0,0,1087,
  	1097,5,63,0,0,1088,1089,5,131,0,0,1089,1090,5,84,0,0,1090,1091,5,131,
  	0,0,1091,1097,5,63,0,0,1092,1093,5,131,0,0,1093,1097,5,85,0,0,1094,1095,
  	5,131,0,0,1095,1097,5,86,0,0,1096,1084,1,0,0,0,1096,1088,1,0,0,0,1096,
  	1092,1,0,0,0,1096,1094,1,0,0,0,1097,1099,1,0,0,0,1098,1100,5,131,0,0,
  	1099,1098,1,0,0,0,1099,1100,1,0,0,0,1100,1101,1,0,0,0,1101,1102,3,128,
  	64,0,1102,125,1,0,0,0,1103,1104,5,131,0,0,1104,1105,5,87,0,0,1105,1106,
  	5,131,0,0,1106,1114,5,88,0,0,1107,1108,5,131,0,0,1108,1109,5,87,0,0,1109,
  	1110,5,131,0,0,1110,1111,5,81,0,0,1111,1112,5,131,0,0,1112,1114,5,88,
  	0,0,1113,1103,1,0,0,0,1113,1107,1,0,0,0,1114,127,1,0,0,0,1115,1122,3,
  	130,65,0,1116,1118,5,131,0,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,1118,
  	1119,1,0,0,0,1119,1121,3,166,83,0,1120,1117,1,0,0,0,1121,1124,1,0,0,0,
  	1122,1120,1,0,0,0,1122,1123,1,0,0,0,1123,1129,1,0,0,0,1124,1122,1,0,0,
  	0,1125,1127,5,131,0,0,1126,1125,1,0,0,0,1126,1127,1,0,0,0,1127,1128,1,
  	0,0,0,1128,1130,3,90,45,0,1129,1126,1,0,0,0,1129,1130,1,0,0,0,1130,129,
  	1,0,0,0,1131,1210,3,132,66,0,1132,1210,3,178,89,0,1133,1210,3,168,84,
  	0,1134,1136,5,89,0,0,1135,1137,5,131,0,0,1136,1135,1,0,0,0,1136,1137,
  	1,0,0,0,1137,1138,1,0,0,0,1138,1140,5,6,0,0,1139,1141,5,131,0,0,1140,
  	1139,1,0,0,0,1140,1141,1,0,0,0,1141,1142,1,0,0,0,1142,1144,5,5,0,0,1143,
  	1145,5,131,0,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,1145,1146,1,0,0,0,
  	1146,1210,5,7,0,0,1147,1210,3,162,81,0,1148,1210,3,164,82,0,1149,1151,
  	5,49,0,0,1150,1152,5,131,0,0,1151,1150,1,0,0,0,1151,1152,1,0,0,0,1152,
  	1153,1,0,0,0,1153,1155,5,6,0,0,1154,1156,5,131,0,0,1155,1154,1,0,0,0,
  	1155,1156,1,0,0,0,1156,1157,1,0,0,0,1157,1159,3,144,72,0,1158,1160,5,
  	131,0,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,1160,1161,1,0,0,0,1161,1162,
  	5,7,0,0,1162,1210,1,0,0,0,1163,1165,5,90,0,0,1164,1166,5,131,0,0,1165,
  	1164,1,0,0,0,1165,1166,1,0,0,0,1166,1167,1,0,0,0,1167,1169,5,6,0,0,1168,
  	1170,5,131,0,0,1169,1168,1,0,0,0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,
  	1171,1173,3,144,72,0,1172,1174,5,131,0,0,1173,1172,1,0,0,0,1173,1174,
  	1,0,0,0,1174,1175,1,0,0,0,1175,1176,5,7,0,0,1176,1210,1,0,0,0,1177,1179,
  	5,91,0,0,1178,1180,5,131,0,0,1179,1178,1,0,0,0,1179,1180,1,0,0,0,1180,
  	1181,1,0,0,0,1181,1183,5,6,0,0,1182,1184,5,131,0,0,1183,1182,1,0,0,0,
  	1183,1184,1,0,0,0,1184,1185,1,0,0,0,1185,1187,3,144,72,0,1186,1188,5,
  	131,0,0,1187,1186,1,0,0,0,1187,1188,1,0,0,0,1188,1189,1,0,0,0,1189,1190,
  	5,7,0,0,1190,1210,1,0,0,0,1191,1193,5,92,0,0,1192,1194,5,131,0,0,1193,
  	1192,1,0,0,0,1193,1194,1,0,0,0,1194,1195,1,0,0,0,1195,1197,5,6,0,0,1196,
  	1198,5,131,0,0,1197,1196,1,0,0,0,1197,1198,1,0,0,0,1198,1199,1,0,0,0,
  	1199,1201,3,144,72,0,1200,1202,5,131,0,0,1201,1200,1,0,0,0,1201,1202,
  	1,0,0,0,1202,1203,1,0,0,0,1203,1204,5,7,0,0,1204,1210,1,0,0,0,1205,1210,
  	3,142,71,0,1206,1210,3,140,70,0,1207,1210,3,148,74,0,1208,1210,3,172,
  	86,0,1209,1131,1,0,0,0,1209,1132,1,0,0,0,1209,1133,1,0,0,0,1209,1134,
  	1,0,0,0,1209,1147,1,0,0,0,1209,1148,1,0,0,0,1209,1149,1,0,0,0,1209,1163,
  	1,0,0,0,1209,1177,1,0,0,0,1209,1191,1,0,0,0,1209,1205,1,0,0,0,1209,1206,
  	1,0,0,0,1209,1207,1,0,0,0,1209,1208,1,0,0,0,1210,131,1,0,0,0,1211,1218,
  	3,174,87,0,1212,1218,5,101,0,0,1213,1218,3,134,67,0,1214,1218,5,88,0,
  	0,1215,1218,3,176,88,0,1216,1218,3,136,68,0,1217,1211,1,0,0,0,1217,1212,
  	1,0,0,0,1217,1213,1,0,0,0,1217,1214,1,0,0,0,1217,1215,1,0,0,0,1217,1216,
  	1,0,0,0,1218,133,1,0,0,0,1219,1220,7,2,0,0,1220,135,1,0,0,0,1221,1223,
  	5,8,0,0,1222,1224,5,131,0,0,1223,1222,1,0,0,0,1223,1224,1,0,0,0,1224,
  	1242,1,0,0,0,1225,1227,3,100,50,0,1226,1228,5,131,0,0,1227,1226,1,0,0,
  	0,1227,1228,1,0,0,0,1228,1239,1,0,0,0,1229,1231,5,2,0,0,1230,1232,5,131,
  	0,0,1231,1230,1,0,0,0,1231,1232,1,0,0,0,1232,1233,1,0,0,0,1233,1235,3,
  	100,50,0,1234,1236,5,131,0,0,1235,1234,1,0,0,0,1235,1236,1,0,0,0,1236,
  	1238,1,0,0,0,1237,1229,1,0,0,0,1238,1241,1,0,0,0,1239,1237,1,0,0,0,1239,
  	1240,1,0,0,0,1240,1243,1,0,0,0,1241,1239,1,0,0,0,1242,1225,1,0,0,0,1242,
  	1243,1,0,0,0,1243,1244,1,0,0,0,1244,1245,5,9,0,0,1245,137,1,0,0,0,1246,
  	1248,5,3,0,0,1247,1249,5,131,0,0,1248,1247,1,0,0,0,1248,1249,1,0,0,0,
  	1249,1250,1,0,0,0,1250,1277,3,112,56,0,1251,1253,5,18,0,0,1252,1254,5,
  	131,0,0,1253,1252,1,0,0,0,1253,1254,1,0,0,0,1254,1255,1,0,0,0,1255,1277,
  	3,112,56,0,1256,1258,5,19,0,0,1257,1259,5,131,0,0,1258,1257,1,0,0,0,1258,
  	1259,1,0,0,0,1259,1260,1,0,0,0,1260,1277,3,112,56,0,1261,1263,5,20,0,
  	0,1262,1264,5,131,0,0,1263,1262,1,0,0,0,1263,1264,1,0,0,0,1264,1265,1,
  	0,0,0,1265,1277,3,112,56,0,1266,1268,5,21,0,0,1267,1269,5,131,0,0,1268,
  	1267,1,0,0,0,1268,1269,1,0,0,0,1269,1270,1,0,0,0,1270,1277,3,112,56,0,
  	1271,1273,5,22,0,0,1272,1274,5,131,0,0,1273,1272,1,0,0,0,1273,1274,1,
  	0,0,0,1274,1275,1,0,0,0,1275,1277,3,112,56,0,1276,1246,1,0,0,0,1276,1251,
  	1,0,0,0,1276,1256,1,0,0,0,1276,1261,1,0,0,0,1276,1266,1,0,0,0,1276,1271,
  	1,0,0,0,1277,139,1,0,0,0,1278,1280,5,6,0,0,1279,1281,5,131,0,0,1280,1279,
  	1,0,0,0,1280,1281,1,0,0,0,1281,1282,1,0,0,0,1282,1284,3,100,50,0,1283,
  	1285,5,131,0,0,1284,1283,1,0,0,0,1284,1285,1,0,0,0,1285,1286,1,0,0,0,
  	1286,1287,5,7,0,0,1287,141,1,0,0,0,1288,1293,3,78,39,0,1289,1291,5,131,
  	0,0,1290,1289,1,0,0,0,1290,1291,1,0,0,0,1291,1292,1,0,0,0,1292,1294,3,
  	80,40,0,1293,1290,1,0,0,0,1294,1295,1,0,0,0,1295,1293,1,0,0,0,1295,1296,
  	1,0,0,0,1296,143,1,0,0,0,1297,1302,3,146,73,0,1298,1300,5,131,0,0,1299,
  	1298,1,0,0,0,1299,1300,1,0,0,0,1300,1301,1,0,0,0,1301,1303,3,68,34,0,
  	1302,1299,1,0,0,0,1302,1303,1,0,0,0,1303,145,1,0,0,0,1304,1305,3,172,
  	86,0,1305,1306,5,131,0,0,1306,1307,5,82,0,0,1307,1308,5,131,0,0,1308,
  	1309,3,100,50,0,1309,147,1,0,0,0,1310,1312,3,150,75,0,1311,1313,5,131,
  	0,0,1312,1311,1,0,0,0,1312,1313,1,0,0,0,1313,1314,1,0,0,0,1314,1316,5,
  	6,0,0,1315,1317,5,131,0,0,1316,1315,1,0,0,0,1316,1317,1,0,0,0,1317,1322,
  	1,0,0,0,1318,1320,5,64,0,0,1319,1321,5,131,0,0,1320,1319,1,0,0,0,1320,
  	1321,1,0,0,0,1321,1323,1,0,0,0,1322,1318,1,0,0,0,1322,1323,1,0,0,0,1323,
  	1341,1,0,0,0,1324,1326,3,100,50,0,1325,1327,5,131,0,0,1326,1325,1,0,0,
  	0,1326,1327,1,0,0,0,1327,1338,1,0,0,0,1328,1330,5,2,0,0,1329,1331,5,131,
  	0,0,1330,1329,1,0,0,0,1330,1331,1,0,0,0,1331,1332,1,0,0,0,1332,1334,3,
  	100,50,0,1333,1335,5,131,0,0,1334,1333,1,0,0,0,1334,1335,1,0,0,0,1335,
  	1337,1,0,0,0,1336,1328,1,0,0,0,1337,1340,1,0,0,0,1338,1336,1,0,0,0,1338,
  	1339,1,0,0,0,1339,1342,1,0,0,0,1340,1338,1,0,0,0,1341,1324,1,0,0,0,1341,
  	1342,1,0,0,0,1342,1343,1,0,0,0,1343,1344,5,7,0,0,1344,149,1,0,0,0,1345,
  	1346,3,160,80,0,1346,1347,3,190,95,0,1347,1350,1,0,0,0,1348,1350,5,95,
  	0,0,1349,1345,1,0,0,0,1349,1348,1,0,0,0,1350,151,1,0,0,0,1351,1353,3,
  	158,79,0,1352,1354,5,131,0,0,1353,1352,1,0,0,0,1353,1354,1,0,0,0,1354,
  	1355,1,0,0,0,1355,1357,5,6,0,0,1356,1358,5,131,0,0,1357,1356,1,0,0,0,
  	1357,1358,1,0,0,0,1358,1376,1,0,0,0,1359,1361,3,100,50,0,1360,1362,5,
  	131,0,0,1361,1360,1,0,0,0,1361,1362,1,0,0,0,1362,1373,1,0,0,0,1363,1365,
  	5,2,0,0,1364,1366,5,131,0,0,1365,1364,1,0,0,0,1365,1366,1,0,0,0,1366,
  	1367,1,0,0,0,1367,1369,3,100,50,0,1368,1370,5,131,0,0,1369,1368,1,0,0,
  	0,1369,1370,1,0,0,0,1370,1372,1,0,0,0,1371,1363,1,0,0,0,1372,1375,1,0,
  	0,0,1373,1371,1,0,0,0,1373,1374,1,0,0,0,1374,1377,1,0,0,0,1375,1373,1,
  	0,0,0,1376,1359,1,0,0,0,1376,1377,1,0,0,0,1377,1378,1,0,0,0,1378,1379,
  	5,7,0,0,1379,153,1,0,0,0,1380,1381,3,158,79,0,1381,155,1,0,0,0,1382,1383,
  	3,190,95,0,1383,157,1,0,0,0,1384,1385,3,160,80,0,1385,1386,3,190,95,0,
  	1386,159,1,0,0,0,1387,1388,3,190,95,0,1388,1389,5,23,0,0,1389,1391,1,
  	0,0,0,1390,1387,1,0,0,0,1391,1394,1,0,0,0,1392,1390,1,0,0,0,1392,1393,
  	1,0,0,0,1393,161,1,0,0,0,1394,1392,1,0,0,0,1395,1397,5,8,0,0,1396,1398,
  	5,131,0,0,1397,1396,1,0,0,0,1397,1398,1,0,0,0,1398,1399,1,0,0,0,1399,
  	1408,3,144,72,0,1400,1402,5,131,0,0,1401,1400,1,0,0,0,1401,1402,1,0,0,
  	0,1402,1403,1,0,0,0,1403,1405,5,11,0,0,1404,1406,5,131,0,0,1405,1404,
  	1,0,0,0,1405,1406,1,0,0,0,1406,1407,1,0,0,0,1407,1409,3,100,50,0,1408,
  	1401,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0,0,0,1410,1412,5,131,0,0,
  	1411,1410,1,0,0,0,1411,1412,1,0,0,0,1412,1413,1,0,0,0,1413,1414,5,9,0,
  	0,1414,163,1,0,0,0,1415,1417,5,8,0,0,1416,1418,5,131,0,0,1417,1416,1,
  	0,0,0,1417,1418,1,0,0,0,1418,1427,1,0,0,0,1419,1421,3,172,86,0,1420,1422,
  	5,131,0,0,1421,1420,1,0,0,0,1421,1422,1,0,0,0,1422,1423,1,0,0,0,1423,
  	1425,5,3,0,0,1424,1426,5,131,0,0,1425,1424,1,0,0,0,1425,1426,1,0,0,0,
  	1426,1428,1,0,0,0,1427,1419,1,0,0,0,1427,1428,1,0,0,0,1428,1429,1,0,0,
  	0,1429,1431,3,142,71,0,1430,1432,5,131,0,0,1431,1430,1,0,0,0,1431,1432,
  	1,0,0,0,1432,1441,1,0,0,0,1433,1435,5,77,0,0,1434,1436,5,131,0,0,1435,
  	1434,1,0,0,0,1435,1436,1,0,0,0,1436,1437,1,0,0,0,1437,1439,3,100,50,0,
  	1438,1440,5,131,0,0,1439,1438,1,0,0,0,1439,1440,1,0,0,0,1440,1442,1,0,
  	0,0,1441,1433,1,0,0,0,1441,1442,1,0,0,0,1442,1443,1,0,0,0,1443,1445,5,
  	11,0,0,1444,1446,5,131,0,0,1445,1444,1,0,0,0,1445,1446,1,0,0,0,1446,1447,
  	1,0,0,0,1447,1449,3,100,50,0,1448,1450,5,131,0,0,1449,1448,1,0,0,0,1449,
  	1450,1,0,0,0,1450,1451,1,0,0,0,1451,1452,5,9,0,0,1452,165,1,0,0,0,1453,
  	1455,5,23,0,0,1454,1456,5,131,0,0,1455,1454,1,0,0,0,1455,1456,1,0,0,0,
  	1456,1457,1,0,0,0,1457,1458,3,182,91,0,1458,167,1,0,0,0,1459,1464,5,96,
  	0,0,1460,1462,5,131,0,0,1461,1460,1,0,0,0,1461,1462,1,0,0,0,1462,1463,
  	1,0,0,0,1463,1465,3,170,85,0,1464,1461,1,0,0,0,1465,1466,1,0,0,0,1466,
  	1464,1,0,0,0,1466,1467,1,0,0,0,1467,1482,1,0,0,0,1468,1470,5,96,0,0,1469,
  	1471,5,131,0,0,1470,1469,1,0,0,0,1470,1471,1,0,0,0,1471,1472,1,0,0,0,
  	1472,1477,3,100,50,0,1473,1475,5,131,0,0,1474,1473,1,0,0,0,1474,1475,
  	1,0,0,0,1475,1476,1,0,0,0,1476,1478,3,170,85,0,1477,1474,1,0,0,0,1478,
  	1479,1,0,0,0,1479,1477,1,0,0,0,1479,1480,1,0,0,0,1480,1482,1,0,0,0,1481,
  	1459,1,0,0,0,1481,1468,1,0,0,0,1482,1491,1,0,0,0,1483,1485,5,131,0,0,
  	1484,1483,1,0,0,0,1484,1485,1,0,0,0,1485,1486,1,0,0,0,1486,1488,5,97,
  	0,0,1487,1489,5,131,0,0,1488,1487,1,0,0,0,1488,1489,1,0,0,0,1489,1490,
  	1,0,0,0,1490,1492,3,100,50,0,1491,1484,1,0,0,0,1491,1492,1,0,0,0,1492,
  	1494,1,0,0,0,1493,1495,5,131,0,0,1494,1493,1,0,0,0,1494,1495,1,0,0,0,
  	1495,1496,1,0,0,0,1496,1497,5,98,0,0,1497,169,1,0,0,0,1498,1500,5,99,
  	0,0,1499,1501,5,131,0,0,1500,1499,1,0,0,0,1500,1501,1,0,0,0,1501,1502,
  	1,0,0,0,1502,1504,3,100,50,0,1503,1505,5,131,0,0,1504,1503,1,0,0,0,1504,
  	1505,1,0,0,0,1505,1506,1,0,0,0,1506,1508,5,100,0,0,1507,1509,5,131,0,
  	0,1508,1507,1,0,0,0,1508,1509,1,0,0,0,1509,1510,1,0,0,0,1510,1511,3,100,
  	50,0,1511,171,1,0,0,0,1512,1513,3,190,95,0,1513,173,1,0,0,0,1514,1517,
  	3,186,93,0,1515,1517,3,184,92,0,1516,1514,1,0,0,0,1516,1515,1,0,0,0,1517,
  	175,1,0,0,0,1518,1520,5,24,0,0,1519,1521,5,131,0,0,1520,1519,1,0,0,0,
  	1520,1521,1,0,0,0,1521,1555,1,0,0,0,1522,1524,3,182,91,0,1523,1525,5,
  	131,0,0,1524,1523,1,0,0,0,1524,1525,1,0,0,0,1525,1526,1,0,0,0,1526,1528,
  	5,10,0,0,1527,1529,5,131,0,0,1528,1527,1,0,0,0,1528,1529,1,0,0,0,1529,
  	1530,1,0,0,0,1530,1532,3,100,50,0,1531,1533,5,131,0,0,1532,1531,1,0,0,
  	0,1532,1533,1,0,0,0,1533,1552,1,0,0,0,1534,1536,5,2,0,0,1535,1537,5,131,
  	0,0,1536,1535,1,0,0,0,1536,1537,1,0,0,0,1537,1538,1,0,0,0,1538,1540,3,
  	182,91,0,1539,1541,5,131,0,0,1540,1539,1,0,0,0,1540,1541,1,0,0,0,1541,
  	1542,1,0,0,0,1542,1544,5,10,0,0,1543,1545,5,131,0,0,1544,1543,1,0,0,0,
  	1544,1545,1,0,0,0,1545,1546,1,0,0,0,1546,1548,3,100,50,0,1547,1549,5,
  	131,0,0,1548,1547,1,0,0,0,1548,1549,1,0,0,0,1549,1551,1,0,0,0,1550,1534,
  	1,0,0,0,1551,1554,1,0,0,0,1552,1550,1,0,0,0,1552,1553,1,0,0,0,1553,1556,
  	1,0,0,0,1554,1552,1,0,0,0,1555,1522,1,0,0,0,1555,1556,1,0,0,0,1556,1557,
  	1,0,0,0,1557,1558,5,25,0,0,1558,177,1,0,0,0,1559,1562,5,26,0,0,1560,1563,
  	3,190,95,0,1561,1563,5,104,0,0,1562,1560,1,0,0,0,1562,1561,1,0,0,0,1563,
  	179,1,0,0,0,1564,1569,3,130,65,0,1565,1567,5,131,0,0,1566,1565,1,0,0,
  	0,1566,1567,1,0,0,0,1567,1568,1,0,0,0,1568,1570,3,166,83,0,1569,1566,
  	1,0,0,0,1570,1571,1,0,0,0,1571,1569,1,0,0,0,1571,1572,1,0,0,0,1572,181,
  	1,0,0,0,1573,1574,3,188,94,0,1574,183,1,0,0,0,1575,1576,7,3,0,0,1576,
  	185,1,0,0,0,1577,1578,7,4,0,0,1578,187,1,0,0,0,1579,1582,3,190,95,0,1580,
  	1582,3,192,96,0,1581,1579,1,0,0,0,1581,1580,1,0,0,0,1582,189,1,0,0,0,
  	1583,1584,7,5,0,0,1584,191,1,0,0,0,1585,1586,7,6,0,0,1586,193,1,0,0,0,
  	1587,1588,7,7,0,0,1588,195,1,0,0,0,1589,1590,7,8,0,0,1590,197,1,0,0,0,
  	1591,1592,7,9,0,0,1592,199,1,0,0,0,293,201,205,208,211,218,223,226,230,
  	234,239,246,251,254,258,262,266,272,276,281,286,290,293,295,299,303,308,
  	312,317,321,330,335,339,343,347,352,356,359,363,373,380,393,397,403,407,
  	411,416,421,425,431,435,441,445,451,455,459,463,467,471,476,483,487,492,
  	499,505,510,516,522,527,531,536,539,542,545,552,558,561,566,569,573,576,
  	584,588,592,596,600,605,610,614,619,622,631,640,645,658,661,677,685,689,
  	694,699,703,708,714,719,726,730,734,736,740,742,746,748,754,760,764,767,
  	770,774,780,784,787,790,796,799,802,806,812,815,818,822,826,830,832,836,
  	838,841,845,847,853,857,861,865,868,873,878,883,888,894,898,900,904,908,
  	910,912,927,937,947,952,956,963,968,973,977,981,985,988,990,995,999,1003,
  	1007,1011,1015,1018,1020,1025,1029,1034,1039,1043,1052,1054,1060,1064,
  	1071,1075,1079,1082,1096,1099,1113,1117,1122,1126,1129,1136,1140,1144,
  	1151,1155,1159,1165,1169,1173,1179,1183,1187,1193,1197,1201,1209,1217,
  	1223,1227,1231,1235,1239,1242,1248,1253,1258,1263,1268,1273,1276,1280,
  	1284,1290,1295,1299,1302,1312,1316,1320,1322,1326,1330,1334,1338,1341,
  	1349,1353,1357,1361,1365,1369,1373,1376,1392,1397,1401,1405,1408,1411,
  	1417,1421,1425,1427,1431,1435,1439,1441,1445,1449,1455,1461,1466,1470,
  	1474,1479,1481,1484,1488,1491,1494,1500,1504,1508,1516,1520,1524,1528,
  	1532,1536,1540,1544,1548,1552,1555,1562,1566,1571,1581
  };
  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));

  antlr4::atn::ATNDeserializer deserializer;
  staticData->atn = deserializer.deserialize(staticData->serializedATN);

  const size_t count = staticData->atn->getNumberOfDecisions();
  staticData->decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
  }
  lcypherParserStaticData = staticData.release();
}

}

LcypherParser::LcypherParser(TokenStream *input) : LcypherParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}

LcypherParser::LcypherParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
  LcypherParser::initialize();
  _interpreter = new atn::ParserATNSimulator(this, *lcypherParserStaticData->atn, lcypherParserStaticData->decisionToDFA, lcypherParserStaticData->sharedContextCache, options);
}

LcypherParser::~LcypherParser() {
  delete _interpreter;
}

const atn::ATN& LcypherParser::getATN() const {
  return *lcypherParserStaticData->atn;
}

std::string LcypherParser::getGrammarFileName() const {
  return "Lcypher.g4";
}

const std::vector<std::string>& LcypherParser::getRuleNames() const {
  return lcypherParserStaticData->ruleNames;
}

const dfa::Vocabulary& LcypherParser::getVocabulary() const {
  return lcypherParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView LcypherParser::getSerializedATN() const {
  return lcypherParserStaticData->serializedATN;
}


//----------------- OC_CypherContext ------------------------------------------------------------------

LcypherParser::OC_CypherContext::OC_CypherContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_StatementContext* LcypherParser::OC_CypherContext::oC_Statement() {
  return getRuleContext<LcypherParser::OC_StatementContext>(0);
}

tree::TerminalNode* LcypherParser::OC_CypherContext::EOF() {
  return getToken(LcypherParser::EOF, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_CypherContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_CypherContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_CypherContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Cypher;
}


std::any LcypherParser::OC_CypherContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Cypher(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_CypherContext* LcypherParser::oC_Cypher() {
  OC_CypherContext *_localctx = _tracker.createInstance<OC_CypherContext>(_ctx, getState());
  enterRule(_localctx, 0, LcypherParser::RuleOC_Cypher);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(201);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(200);
      match(LcypherParser::SP);
    }
    setState(203);
    oC_Statement();
    setState(208);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
    case 1: {
      setState(205);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(204);
        match(LcypherParser::SP);
      }
      setState(207);
      match(LcypherParser::T__0);
      break;
    }

    default:
      break;
    }
    setState(211);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(210);
      match(LcypherParser::SP);
    }
    setState(213);
    match(LcypherParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_StatementContext ------------------------------------------------------------------

LcypherParser::OC_StatementContext::OC_StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_QueryContext* LcypherParser::OC_StatementContext::oC_Query() {
  return getRuleContext<LcypherParser::OC_QueryContext>(0);
}

tree::TerminalNode* LcypherParser::OC_StatementContext::EXPLAIN() {
  return getToken(LcypherParser::EXPLAIN, 0);
}

tree::TerminalNode* LcypherParser::OC_StatementContext::SP() {
  return getToken(LcypherParser::SP, 0);
}

tree::TerminalNode* LcypherParser::OC_StatementContext::PROFILE() {
  return getToken(LcypherParser::PROFILE, 0);
}


size_t LcypherParser::OC_StatementContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Statement;
}


std::any LcypherParser::OC_StatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Statement(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_StatementContext* LcypherParser::oC_Statement() {
  OC_StatementContext *_localctx = _tracker.createInstance<OC_StatementContext>(_ctx, getState());
  enterRule(_localctx, 2, LcypherParser::RuleOC_Statement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(226);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::OPTIONAL_:
      case LcypherParser::MATCH:
      case LcypherParser::UNWIND:
      case LcypherParser::MERGE:
      case LcypherParser::CREATE:
      case LcypherParser::SET:
      case LcypherParser::DETACH:
      case LcypherParser::DELETE_:
      case LcypherParser::REMOVE:
      case LcypherParser::CALL:
      case LcypherParser::WITH:
      case LcypherParser::RETURN: {
        enterOuterAlt(_localctx, 1);
        setState(215);
        oC_Query();
        break;
      }

      case LcypherParser::EXPLAIN: {
        enterOuterAlt(_localctx, 2);
        setState(216);
        match(LcypherParser::EXPLAIN);
        setState(218);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(217);
          match(LcypherParser::SP);
        }
        setState(220);
        oC_Query();
        break;
      }

      case LcypherParser::PROFILE: {
        enterOuterAlt(_localctx, 3);
        setState(221);
        match(LcypherParser::PROFILE);
        setState(223);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(222);
          match(LcypherParser::SP);
        }
        setState(225);
        oC_Query();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_QueryContext ------------------------------------------------------------------

LcypherParser::OC_QueryContext::OC_QueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_RegularQueryContext* LcypherParser::OC_QueryContext::oC_RegularQuery() {
  return getRuleContext<LcypherParser::OC_RegularQueryContext>(0);
}

LcypherParser::OC_StandaloneCallContext* LcypherParser::OC_QueryContext::oC_StandaloneCall() {
  return getRuleContext<LcypherParser::OC_StandaloneCallContext>(0);
}


size_t LcypherParser::OC_QueryContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Query;
}


std::any LcypherParser::OC_QueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Query(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_QueryContext* LcypherParser::oC_Query() {
  OC_QueryContext *_localctx = _tracker.createInstance<OC_QueryContext>(_ctx, getState());
  enterRule(_localctx, 4, LcypherParser::RuleOC_Query);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(230);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(228);
      oC_RegularQuery();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(229);
      oC_StandaloneCall();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RegularQueryContext ------------------------------------------------------------------

LcypherParser::OC_RegularQueryContext::OC_RegularQueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SingleQueryContext* LcypherParser::OC_RegularQueryContext::oC_SingleQuery() {
  return getRuleContext<LcypherParser::OC_SingleQueryContext>(0);
}

std::vector<LcypherParser::OC_UnionContext *> LcypherParser::OC_RegularQueryContext::oC_Union() {
  return getRuleContexts<LcypherParser::OC_UnionContext>();
}

LcypherParser::OC_UnionContext* LcypherParser::OC_RegularQueryContext::oC_Union(size_t i) {
  return getRuleContext<LcypherParser::OC_UnionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RegularQueryContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RegularQueryContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_RegularQueryContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RegularQuery;
}


std::any LcypherParser::OC_RegularQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RegularQuery(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RegularQueryContext* LcypherParser::oC_RegularQuery() {
  OC_RegularQueryContext *_localctx = _tracker.createInstance<OC_RegularQueryContext>(_ctx, getState());
  enterRule(_localctx, 6, LcypherParser::RuleOC_RegularQuery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(232);
    oC_SingleQuery();
    setState(239);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(234);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(233);
          match(LcypherParser::SP);
        }
        setState(236);
        oC_Union(); 
      }
      setState(241);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UnionContext ------------------------------------------------------------------

LcypherParser::OC_UnionContext::OC_UnionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_UnionContext::UNION() {
  return getToken(LcypherParser::UNION, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_UnionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_UnionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_UnionContext::ALL() {
  return getToken(LcypherParser::ALL, 0);
}

LcypherParser::OC_SingleQueryContext* LcypherParser::OC_UnionContext::oC_SingleQuery() {
  return getRuleContext<LcypherParser::OC_SingleQueryContext>(0);
}


size_t LcypherParser::OC_UnionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Union;
}


std::any LcypherParser::OC_UnionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Union(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_UnionContext* LcypherParser::oC_Union() {
  OC_UnionContext *_localctx = _tracker.createInstance<OC_UnionContext>(_ctx, getState());
  enterRule(_localctx, 8, LcypherParser::RuleOC_Union);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(254);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(242);
      match(LcypherParser::UNION);
      setState(243);
      match(LcypherParser::SP);
      setState(244);
      match(LcypherParser::ALL);
      setState(246);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(245);
        match(LcypherParser::SP);
      }
      setState(248);
      oC_SingleQuery();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(249);
      match(LcypherParser::UNION);
      setState(251);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(250);
        match(LcypherParser::SP);
      }
      setState(253);
      oC_SingleQuery();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SingleQueryContext ------------------------------------------------------------------

LcypherParser::OC_SingleQueryContext::OC_SingleQueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SinglePartQueryContext* LcypherParser::OC_SingleQueryContext::oC_SinglePartQuery() {
  return getRuleContext<LcypherParser::OC_SinglePartQueryContext>(0);
}

LcypherParser::OC_MultiPartQueryContext* LcypherParser::OC_SingleQueryContext::oC_MultiPartQuery() {
  return getRuleContext<LcypherParser::OC_MultiPartQueryContext>(0);
}


size_t LcypherParser::OC_SingleQueryContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SingleQuery;
}


std::any LcypherParser::OC_SingleQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SingleQuery(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SingleQueryContext* LcypherParser::oC_SingleQuery() {
  OC_SingleQueryContext *_localctx = _tracker.createInstance<OC_SingleQueryContext>(_ctx, getState());
  enterRule(_localctx, 10, LcypherParser::RuleOC_SingleQuery);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(258);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(256);
      oC_SinglePartQuery();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(257);
      oC_MultiPartQuery();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SinglePartQueryContext ------------------------------------------------------------------

LcypherParser::OC_SinglePartQueryContext::OC_SinglePartQueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ReturnContext* LcypherParser::OC_SinglePartQueryContext::oC_Return() {
  return getRuleContext<LcypherParser::OC_ReturnContext>(0);
}

std::vector<LcypherParser::OC_ReadingClauseContext *> LcypherParser::OC_SinglePartQueryContext::oC_ReadingClause() {
  return getRuleContexts<LcypherParser::OC_ReadingClauseContext>();
}

LcypherParser::OC_ReadingClauseContext* LcypherParser::OC_SinglePartQueryContext::oC_ReadingClause(size_t i) {
  return getRuleContext<LcypherParser::OC_ReadingClauseContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_SinglePartQueryContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_SinglePartQueryContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_UpdatingClauseContext *> LcypherParser::OC_SinglePartQueryContext::oC_UpdatingClause() {
  return getRuleContexts<LcypherParser::OC_UpdatingClauseContext>();
}

LcypherParser::OC_UpdatingClauseContext* LcypherParser::OC_SinglePartQueryContext::oC_UpdatingClause(size_t i) {
  return getRuleContext<LcypherParser::OC_UpdatingClauseContext>(i);
}


size_t LcypherParser::OC_SinglePartQueryContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SinglePartQuery;
}


std::any LcypherParser::OC_SinglePartQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SinglePartQuery(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SinglePartQueryContext* LcypherParser::oC_SinglePartQuery() {
  OC_SinglePartQueryContext *_localctx = _tracker.createInstance<OC_SinglePartQueryContext>(_ctx, getState());
  enterRule(_localctx, 12, LcypherParser::RuleOC_SinglePartQuery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(295);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(266);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 2313724308561592320) != 0)) {
        setState(260);
        oC_ReadingClause();
        setState(262);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(261);
          match(LcypherParser::SP);
        }
        setState(268);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(269);
      oC_Return();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(276);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 2313724308561592320) != 0)) {
        setState(270);
        oC_ReadingClause();
        setState(272);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(271);
          match(LcypherParser::SP);
        }
        setState(278);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(279);
      oC_UpdatingClause();
      setState(286);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(281);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(280);
            match(LcypherParser::SP);
          }
          setState(283);
          oC_UpdatingClause(); 
        }
        setState(288);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx);
      }
      setState(293);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {
      case 1: {
        setState(290);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(289);
          match(LcypherParser::SP);
        }
        setState(292);
        oC_Return();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MultiPartQueryContext ------------------------------------------------------------------

LcypherParser::OC_MultiPartQueryContext::OC_MultiPartQueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SinglePartQueryContext* LcypherParser::OC_MultiPartQueryContext::oC_SinglePartQuery() {
  return getRuleContext<LcypherParser::OC_SinglePartQueryContext>(0);
}

std::vector<LcypherParser::OC_WithContext *> LcypherParser::OC_MultiPartQueryContext::oC_With() {
  return getRuleContexts<LcypherParser::OC_WithContext>();
}

LcypherParser::OC_WithContext* LcypherParser::OC_MultiPartQueryContext::oC_With(size_t i) {
  return getRuleContext<LcypherParser::OC_WithContext>(i);
}

std::vector<LcypherParser::OC_ReadingClauseContext *> LcypherParser::OC_MultiPartQueryContext::oC_ReadingClause() {
  return getRuleContexts<LcypherParser::OC_ReadingClauseContext>();
}

LcypherParser::OC_ReadingClauseContext* LcypherParser::OC_MultiPartQueryContext::oC_ReadingClause(size_t i) {
  return getRuleContext<LcypherParser::OC_ReadingClauseContext>(i);
}

std::vector<LcypherParser::OC_UpdatingClauseContext *> LcypherParser::OC_MultiPartQueryContext::oC_UpdatingClause() {
  return getRuleContexts<LcypherParser::OC_UpdatingClauseContext>();
}

LcypherParser::OC_UpdatingClauseContext* LcypherParser::OC_MultiPartQueryContext::oC_UpdatingClause(size_t i) {
  return getRuleContext<LcypherParser::OC_UpdatingClauseContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MultiPartQueryContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MultiPartQueryContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_MultiPartQueryContext::getRuleIndex() const {
  return LcypherParser::RuleOC_MultiPartQuery;
}


std::any LcypherParser::OC_MultiPartQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_MultiPartQuery(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MultiPartQueryContext* LcypherParser::oC_MultiPartQuery() {
  OC_MultiPartQueryContext *_localctx = _tracker.createInstance<OC_MultiPartQueryContext>(_ctx, getState());
  enterRule(_localctx, 14, LcypherParser::RuleOC_MultiPartQuery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(319); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(303);
              _errHandler->sync(this);
              _la = _input->LA(1);
              while ((((_la & ~ 0x3fULL) == 0) &&
                ((1ULL << _la) & 2313724308561592320) != 0)) {
                setState(297);
                oC_ReadingClause();
                setState(299);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == LcypherParser::SP) {
                  setState(298);
                  match(LcypherParser::SP);
                }
                setState(305);
                _errHandler->sync(this);
                _la = _input->LA(1);
              }
              setState(312);
              _errHandler->sync(this);
              _la = _input->LA(1);
              while ((((_la & ~ 0x3fULL) == 0) &&
                ((1ULL << _la) & 2251799813685248000) != 0)) {
                setState(306);
                oC_UpdatingClause();
                setState(308);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == LcypherParser::SP) {
                  setState(307);
                  match(LcypherParser::SP);
                }
                setState(314);
                _errHandler->sync(this);
                _la = _input->LA(1);
              }
              setState(315);
              oC_With();
              setState(317);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == LcypherParser::SP) {
                setState(316);
                match(LcypherParser::SP);
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(321); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(323);
    oC_SinglePartQuery();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UpdatingClauseContext ------------------------------------------------------------------

LcypherParser::OC_UpdatingClauseContext::OC_UpdatingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_CreateContext* LcypherParser::OC_UpdatingClauseContext::oC_Create() {
  return getRuleContext<LcypherParser::OC_CreateContext>(0);
}

LcypherParser::OC_MergeContext* LcypherParser::OC_UpdatingClauseContext::oC_Merge() {
  return getRuleContext<LcypherParser::OC_MergeContext>(0);
}

LcypherParser::OC_DeleteContext* LcypherParser::OC_UpdatingClauseContext::oC_Delete() {
  return getRuleContext<LcypherParser::OC_DeleteContext>(0);
}

LcypherParser::OC_SetContext* LcypherParser::OC_UpdatingClauseContext::oC_Set() {
  return getRuleContext<LcypherParser::OC_SetContext>(0);
}

LcypherParser::OC_RemoveContext* LcypherParser::OC_UpdatingClauseContext::oC_Remove() {
  return getRuleContext<LcypherParser::OC_RemoveContext>(0);
}


size_t LcypherParser::OC_UpdatingClauseContext::getRuleIndex() const {
  return LcypherParser::RuleOC_UpdatingClause;
}


std::any LcypherParser::OC_UpdatingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_UpdatingClause(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_UpdatingClauseContext* LcypherParser::oC_UpdatingClause() {
  OC_UpdatingClauseContext *_localctx = _tracker.createInstance<OC_UpdatingClauseContext>(_ctx, getState());
  enterRule(_localctx, 16, LcypherParser::RuleOC_UpdatingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(330);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::CREATE: {
        enterOuterAlt(_localctx, 1);
        setState(325);
        oC_Create();
        break;
      }

      case LcypherParser::MERGE: {
        enterOuterAlt(_localctx, 2);
        setState(326);
        oC_Merge();
        break;
      }

      case LcypherParser::DETACH:
      case LcypherParser::DELETE_: {
        enterOuterAlt(_localctx, 3);
        setState(327);
        oC_Delete();
        break;
      }

      case LcypherParser::SET: {
        enterOuterAlt(_localctx, 4);
        setState(328);
        oC_Set();
        break;
      }

      case LcypherParser::REMOVE: {
        enterOuterAlt(_localctx, 5);
        setState(329);
        oC_Remove();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReadingClauseContext ------------------------------------------------------------------

LcypherParser::OC_ReadingClauseContext::OC_ReadingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_MatchContext* LcypherParser::OC_ReadingClauseContext::oC_Match() {
  return getRuleContext<LcypherParser::OC_MatchContext>(0);
}

LcypherParser::OC_UnwindContext* LcypherParser::OC_ReadingClauseContext::oC_Unwind() {
  return getRuleContext<LcypherParser::OC_UnwindContext>(0);
}

LcypherParser::OC_InQueryCallContext* LcypherParser::OC_ReadingClauseContext::oC_InQueryCall() {
  return getRuleContext<LcypherParser::OC_InQueryCallContext>(0);
}


size_t LcypherParser::OC_ReadingClauseContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ReadingClause;
}


std::any LcypherParser::OC_ReadingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ReadingClause(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReadingClauseContext* LcypherParser::oC_ReadingClause() {
  OC_ReadingClauseContext *_localctx = _tracker.createInstance<OC_ReadingClauseContext>(_ctx, getState());
  enterRule(_localctx, 18, LcypherParser::RuleOC_ReadingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(335);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::OPTIONAL_:
      case LcypherParser::MATCH: {
        enterOuterAlt(_localctx, 1);
        setState(332);
        oC_Match();
        break;
      }

      case LcypherParser::UNWIND: {
        enterOuterAlt(_localctx, 2);
        setState(333);
        oC_Unwind();
        break;
      }

      case LcypherParser::CALL: {
        enterOuterAlt(_localctx, 3);
        setState(334);
        oC_InQueryCall();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MatchContext ------------------------------------------------------------------

LcypherParser::OC_MatchContext::OC_MatchContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_MatchContext::MATCH() {
  return getToken(LcypherParser::MATCH, 0);
}

LcypherParser::OC_PatternContext* LcypherParser::OC_MatchContext::oC_Pattern() {
  return getRuleContext<LcypherParser::OC_PatternContext>(0);
}

tree::TerminalNode* LcypherParser::OC_MatchContext::OPTIONAL_() {
  return getToken(LcypherParser::OPTIONAL_, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MatchContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MatchContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_HintContext *> LcypherParser::OC_MatchContext::oC_Hint() {
  return getRuleContexts<LcypherParser::OC_HintContext>();
}

LcypherParser::OC_HintContext* LcypherParser::OC_MatchContext::oC_Hint(size_t i) {
  return getRuleContext<LcypherParser::OC_HintContext>(i);
}

LcypherParser::OC_WhereContext* LcypherParser::OC_MatchContext::oC_Where() {
  return getRuleContext<LcypherParser::OC_WhereContext>(0);
}


size_t LcypherParser::OC_MatchContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Match;
}


std::any LcypherParser::OC_MatchContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Match(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MatchContext* LcypherParser::oC_Match() {
  OC_MatchContext *_localctx = _tracker.createInstance<OC_MatchContext>(_ctx, getState());
  enterRule(_localctx, 20, LcypherParser::RuleOC_Match);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(339);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::OPTIONAL_) {
      setState(337);
      match(LcypherParser::OPTIONAL_);
      setState(338);
      match(LcypherParser::SP);
    }
    setState(341);
    match(LcypherParser::MATCH);
    setState(343);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(342);
      match(LcypherParser::SP);
    }
    setState(345);
    oC_Pattern();
    setState(352);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(347);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(346);
          match(LcypherParser::SP);
        }
        setState(349);
        oC_Hint(); 
      }
      setState(354);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx);
    }
    setState(359);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx)) {
    case 1: {
      setState(356);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(355);
        match(LcypherParser::SP);
      }
      setState(358);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UnwindContext ------------------------------------------------------------------

LcypherParser::OC_UnwindContext::OC_UnwindContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_UnwindContext::UNWIND() {
  return getToken(LcypherParser::UNWIND, 0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_UnwindContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_UnwindContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_UnwindContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_UnwindContext::AS() {
  return getToken(LcypherParser::AS, 0);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_UnwindContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}


size_t LcypherParser::OC_UnwindContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Unwind;
}


std::any LcypherParser::OC_UnwindContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Unwind(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_UnwindContext* LcypherParser::oC_Unwind() {
  OC_UnwindContext *_localctx = _tracker.createInstance<OC_UnwindContext>(_ctx, getState());
  enterRule(_localctx, 22, LcypherParser::RuleOC_Unwind);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(361);
    match(LcypherParser::UNWIND);
    setState(363);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(362);
      match(LcypherParser::SP);
    }
    setState(365);
    oC_Expression();
    setState(366);
    match(LcypherParser::SP);
    setState(367);
    match(LcypherParser::AS);
    setState(368);
    match(LcypherParser::SP);
    setState(369);
    oC_Variable();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MergeContext ------------------------------------------------------------------

LcypherParser::OC_MergeContext::OC_MergeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_MergeContext::MERGE() {
  return getToken(LcypherParser::MERGE, 0);
}

LcypherParser::OC_PatternPartContext* LcypherParser::OC_MergeContext::oC_PatternPart() {
  return getRuleContext<LcypherParser::OC_PatternPartContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MergeContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MergeContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_MergeActionContext *> LcypherParser::OC_MergeContext::oC_MergeAction() {
  return getRuleContexts<LcypherParser::OC_MergeActionContext>();
}

LcypherParser::OC_MergeActionContext* LcypherParser::OC_MergeContext::oC_MergeAction(size_t i) {
  return getRuleContext<LcypherParser::OC_MergeActionContext>(i);
}


size_t LcypherParser::OC_MergeContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Merge;
}


std::any LcypherParser::OC_MergeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Merge(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MergeContext* LcypherParser::oC_Merge() {
  OC_MergeContext *_localctx = _tracker.createInstance<OC_MergeContext>(_ctx, getState());
  enterRule(_localctx, 24, LcypherParser::RuleOC_Merge);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(371);
    match(LcypherParser::MERGE);
    setState(373);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(372);
      match(LcypherParser::SP);
    }
    setState(375);
    oC_PatternPart();
    setState(380);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(376);
        match(LcypherParser::SP);
        setState(377);
        oC_MergeAction(); 
      }
      setState(382);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MergeActionContext ------------------------------------------------------------------

LcypherParser::OC_MergeActionContext::OC_MergeActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_MergeActionContext::ON() {
  return getToken(LcypherParser::ON, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MergeActionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MergeActionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_MergeActionContext::MATCH() {
  return getToken(LcypherParser::MATCH, 0);
}

LcypherParser::OC_SetContext* LcypherParser::OC_MergeActionContext::oC_Set() {
  return getRuleContext<LcypherParser::OC_SetContext>(0);
}

tree::TerminalNode* LcypherParser::OC_MergeActionContext::CREATE() {
  return getToken(LcypherParser::CREATE, 0);
}


size_t LcypherParser::OC_MergeActionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_MergeAction;
}


std::any LcypherParser::OC_MergeActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_MergeAction(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MergeActionContext* LcypherParser::oC_MergeAction() {
  OC_MergeActionContext *_localctx = _tracker.createInstance<OC_MergeActionContext>(_ctx, getState());
  enterRule(_localctx, 26, LcypherParser::RuleOC_MergeAction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(393);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(383);
      match(LcypherParser::ON);
      setState(384);
      match(LcypherParser::SP);
      setState(385);
      match(LcypherParser::MATCH);
      setState(386);
      match(LcypherParser::SP);
      setState(387);
      oC_Set();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(388);
      match(LcypherParser::ON);
      setState(389);
      match(LcypherParser::SP);
      setState(390);
      match(LcypherParser::CREATE);
      setState(391);
      match(LcypherParser::SP);
      setState(392);
      oC_Set();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CreateContext ------------------------------------------------------------------

LcypherParser::OC_CreateContext::OC_CreateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_CreateContext::CREATE() {
  return getToken(LcypherParser::CREATE, 0);
}

LcypherParser::OC_PatternContext* LcypherParser::OC_CreateContext::oC_Pattern() {
  return getRuleContext<LcypherParser::OC_PatternContext>(0);
}

tree::TerminalNode* LcypherParser::OC_CreateContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_CreateContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Create;
}


std::any LcypherParser::OC_CreateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Create(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_CreateContext* LcypherParser::oC_Create() {
  OC_CreateContext *_localctx = _tracker.createInstance<OC_CreateContext>(_ctx, getState());
  enterRule(_localctx, 28, LcypherParser::RuleOC_Create);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(395);
    match(LcypherParser::CREATE);
    setState(397);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(396);
      match(LcypherParser::SP);
    }
    setState(399);
    oC_Pattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SetContext ------------------------------------------------------------------

LcypherParser::OC_SetContext::OC_SetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_SetContext::SET() {
  return getToken(LcypherParser::SET, 0);
}

std::vector<LcypherParser::OC_SetItemContext *> LcypherParser::OC_SetContext::oC_SetItem() {
  return getRuleContexts<LcypherParser::OC_SetItemContext>();
}

LcypherParser::OC_SetItemContext* LcypherParser::OC_SetContext::oC_SetItem(size_t i) {
  return getRuleContext<LcypherParser::OC_SetItemContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_SetContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_SetContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_SetContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Set;
}


std::any LcypherParser::OC_SetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Set(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SetContext* LcypherParser::oC_Set() {
  OC_SetContext *_localctx = _tracker.createInstance<OC_SetContext>(_ctx, getState());
  enterRule(_localctx, 30, LcypherParser::RuleOC_Set);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(401);
    match(LcypherParser::SET);
    setState(403);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(402);
      match(LcypherParser::SP);
    }
    setState(405);
    oC_SetItem();
    setState(416);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(407);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(406);
          match(LcypherParser::SP);
        }
        setState(409);
        match(LcypherParser::T__1);
        setState(411);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(410);
          match(LcypherParser::SP);
        }
        setState(413);
        oC_SetItem(); 
      }
      setState(418);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SetItemContext ------------------------------------------------------------------

LcypherParser::OC_SetItemContext::OC_SetItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_PropertyExpressionContext* LcypherParser::OC_SetItemContext::oC_PropertyExpression() {
  return getRuleContext<LcypherParser::OC_PropertyExpressionContext>(0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_SetItemContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_SetItemContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_SetItemContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_SetItemContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_NodeLabelsContext* LcypherParser::OC_SetItemContext::oC_NodeLabels() {
  return getRuleContext<LcypherParser::OC_NodeLabelsContext>(0);
}


size_t LcypherParser::OC_SetItemContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SetItem;
}


std::any LcypherParser::OC_SetItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SetItem(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SetItemContext* LcypherParser::oC_SetItem() {
  OC_SetItemContext *_localctx = _tracker.createInstance<OC_SetItemContext>(_ctx, getState());
  enterRule(_localctx, 32, LcypherParser::RuleOC_SetItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(455);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(419);
      oC_PropertyExpression();
      setState(421);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(420);
        match(LcypherParser::SP);
      }
      setState(423);
      match(LcypherParser::T__2);
      setState(425);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(424);
        match(LcypherParser::SP);
      }
      setState(427);
      oC_Expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(429);
      oC_Variable();
      setState(431);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(430);
        match(LcypherParser::SP);
      }
      setState(433);
      match(LcypherParser::T__2);
      setState(435);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(434);
        match(LcypherParser::SP);
      }
      setState(437);
      oC_Expression();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(439);
      oC_Variable();
      setState(441);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(440);
        match(LcypherParser::SP);
      }
      setState(443);
      match(LcypherParser::T__3);
      setState(445);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(444);
        match(LcypherParser::SP);
      }
      setState(447);
      oC_Expression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(449);
      oC_Variable();
      setState(451);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(450);
        match(LcypherParser::SP);
      }
      setState(453);
      oC_NodeLabels();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_DeleteContext ------------------------------------------------------------------

LcypherParser::OC_DeleteContext::OC_DeleteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_DeleteContext::DELETE_() {
  return getToken(LcypherParser::DELETE_, 0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_DeleteContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_DeleteContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}

tree::TerminalNode* LcypherParser::OC_DeleteContext::DETACH() {
  return getToken(LcypherParser::DETACH, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_DeleteContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_DeleteContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_DeleteContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Delete;
}


std::any LcypherParser::OC_DeleteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Delete(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_DeleteContext* LcypherParser::oC_Delete() {
  OC_DeleteContext *_localctx = _tracker.createInstance<OC_DeleteContext>(_ctx, getState());
  enterRule(_localctx, 34, LcypherParser::RuleOC_Delete);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(459);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::DETACH) {
      setState(457);
      match(LcypherParser::DETACH);
      setState(458);
      match(LcypherParser::SP);
    }
    setState(461);
    match(LcypherParser::DELETE_);
    setState(463);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(462);
      match(LcypherParser::SP);
    }
    setState(465);
    oC_Expression();
    setState(476);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(467);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(466);
          match(LcypherParser::SP);
        }
        setState(469);
        match(LcypherParser::T__1);
        setState(471);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(470);
          match(LcypherParser::SP);
        }
        setState(473);
        oC_Expression(); 
      }
      setState(478);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RemoveContext ------------------------------------------------------------------

LcypherParser::OC_RemoveContext::OC_RemoveContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_RemoveContext::REMOVE() {
  return getToken(LcypherParser::REMOVE, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RemoveContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RemoveContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_RemoveItemContext *> LcypherParser::OC_RemoveContext::oC_RemoveItem() {
  return getRuleContexts<LcypherParser::OC_RemoveItemContext>();
}

LcypherParser::OC_RemoveItemContext* LcypherParser::OC_RemoveContext::oC_RemoveItem(size_t i) {
  return getRuleContext<LcypherParser::OC_RemoveItemContext>(i);
}


size_t LcypherParser::OC_RemoveContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Remove;
}


std::any LcypherParser::OC_RemoveContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Remove(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RemoveContext* LcypherParser::oC_Remove() {
  OC_RemoveContext *_localctx = _tracker.createInstance<OC_RemoveContext>(_ctx, getState());
  enterRule(_localctx, 36, LcypherParser::RuleOC_Remove);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(479);
    match(LcypherParser::REMOVE);
    setState(480);
    match(LcypherParser::SP);
    setState(481);
    oC_RemoveItem();
    setState(492);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(483);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(482);
          match(LcypherParser::SP);
        }
        setState(485);
        match(LcypherParser::T__1);
        setState(487);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(486);
          match(LcypherParser::SP);
        }
        setState(489);
        oC_RemoveItem(); 
      }
      setState(494);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RemoveItemContext ------------------------------------------------------------------

LcypherParser::OC_RemoveItemContext::OC_RemoveItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_VariableContext* LcypherParser::OC_RemoveItemContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_NodeLabelsContext* LcypherParser::OC_RemoveItemContext::oC_NodeLabels() {
  return getRuleContext<LcypherParser::OC_NodeLabelsContext>(0);
}

LcypherParser::OC_PropertyExpressionContext* LcypherParser::OC_RemoveItemContext::oC_PropertyExpression() {
  return getRuleContext<LcypherParser::OC_PropertyExpressionContext>(0);
}


size_t LcypherParser::OC_RemoveItemContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RemoveItem;
}


std::any LcypherParser::OC_RemoveItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RemoveItem(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RemoveItemContext* LcypherParser::oC_RemoveItem() {
  OC_RemoveItemContext *_localctx = _tracker.createInstance<OC_RemoveItemContext>(_ctx, getState());
  enterRule(_localctx, 38, LcypherParser::RuleOC_RemoveItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(499);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(495);
      oC_Variable();
      setState(496);
      oC_NodeLabels();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(498);
      oC_PropertyExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_InQueryCallContext ------------------------------------------------------------------

LcypherParser::OC_InQueryCallContext::OC_InQueryCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_InQueryCallContext::CALL() {
  return getToken(LcypherParser::CALL, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_InQueryCallContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_InQueryCallContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ExplicitProcedureInvocationContext* LcypherParser::OC_InQueryCallContext::oC_ExplicitProcedureInvocation() {
  return getRuleContext<LcypherParser::OC_ExplicitProcedureInvocationContext>(0);
}

tree::TerminalNode* LcypherParser::OC_InQueryCallContext::YIELD() {
  return getToken(LcypherParser::YIELD, 0);
}

LcypherParser::OC_YieldItemsContext* LcypherParser::OC_InQueryCallContext::oC_YieldItems() {
  return getRuleContext<LcypherParser::OC_YieldItemsContext>(0);
}


size_t LcypherParser::OC_InQueryCallContext::getRuleIndex() const {
  return LcypherParser::RuleOC_InQueryCall;
}


std::any LcypherParser::OC_InQueryCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_InQueryCall(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_InQueryCallContext* LcypherParser::oC_InQueryCall() {
  OC_InQueryCallContext *_localctx = _tracker.createInstance<OC_InQueryCallContext>(_ctx, getState());
  enterRule(_localctx, 40, LcypherParser::RuleOC_InQueryCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(501);
    match(LcypherParser::CALL);
    setState(502);
    match(LcypherParser::SP);
    setState(503);
    oC_ExplicitProcedureInvocation();
    setState(510);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx)) {
    case 1: {
      setState(505);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(504);
        match(LcypherParser::SP);
      }
      setState(507);
      match(LcypherParser::YIELD);
      setState(508);
      match(LcypherParser::SP);
      setState(509);
      oC_YieldItems();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_StandaloneCallContext ------------------------------------------------------------------

LcypherParser::OC_StandaloneCallContext::OC_StandaloneCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_StandaloneCallContext::CALL() {
  return getToken(LcypherParser::CALL, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_StandaloneCallContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_StandaloneCallContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ExplicitProcedureInvocationContext* LcypherParser::OC_StandaloneCallContext::oC_ExplicitProcedureInvocation() {
  return getRuleContext<LcypherParser::OC_ExplicitProcedureInvocationContext>(0);
}

LcypherParser::OC_ImplicitProcedureInvocationContext* LcypherParser::OC_StandaloneCallContext::oC_ImplicitProcedureInvocation() {
  return getRuleContext<LcypherParser::OC_ImplicitProcedureInvocationContext>(0);
}

tree::TerminalNode* LcypherParser::OC_StandaloneCallContext::YIELD() {
  return getToken(LcypherParser::YIELD, 0);
}

LcypherParser::OC_YieldItemsContext* LcypherParser::OC_StandaloneCallContext::oC_YieldItems() {
  return getRuleContext<LcypherParser::OC_YieldItemsContext>(0);
}


size_t LcypherParser::OC_StandaloneCallContext::getRuleIndex() const {
  return LcypherParser::RuleOC_StandaloneCall;
}


std::any LcypherParser::OC_StandaloneCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_StandaloneCall(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_StandaloneCallContext* LcypherParser::oC_StandaloneCall() {
  OC_StandaloneCallContext *_localctx = _tracker.createInstance<OC_StandaloneCallContext>(_ctx, getState());
  enterRule(_localctx, 42, LcypherParser::RuleOC_StandaloneCall);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(512);
    match(LcypherParser::CALL);
    setState(513);
    match(LcypherParser::SP);
    setState(516);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
    case 1: {
      setState(514);
      oC_ExplicitProcedureInvocation();
      break;
    }

    case 2: {
      setState(515);
      oC_ImplicitProcedureInvocation();
      break;
    }

    default:
      break;
    }
    setState(522);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
    case 1: {
      setState(518);
      match(LcypherParser::SP);
      setState(519);
      match(LcypherParser::YIELD);
      setState(520);
      match(LcypherParser::SP);
      setState(521);
      oC_YieldItems();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_YieldItemsContext ------------------------------------------------------------------

LcypherParser::OC_YieldItemsContext::OC_YieldItemsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_WhereContext* LcypherParser::OC_YieldItemsContext::oC_Where() {
  return getRuleContext<LcypherParser::OC_WhereContext>(0);
}

std::vector<LcypherParser::OC_YieldItemContext *> LcypherParser::OC_YieldItemsContext::oC_YieldItem() {
  return getRuleContexts<LcypherParser::OC_YieldItemContext>();
}

LcypherParser::OC_YieldItemContext* LcypherParser::OC_YieldItemsContext::oC_YieldItem(size_t i) {
  return getRuleContext<LcypherParser::OC_YieldItemContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_YieldItemsContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_YieldItemsContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_YieldItemsContext::getRuleIndex() const {
  return LcypherParser::RuleOC_YieldItems;
}


std::any LcypherParser::OC_YieldItemsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_YieldItems(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_YieldItemsContext* LcypherParser::oC_YieldItems() {
  OC_YieldItemsContext *_localctx = _tracker.createInstance<OC_YieldItemsContext>(_ctx, getState());
  enterRule(_localctx, 44, LcypherParser::RuleOC_YieldItems);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(539);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::T__4: {
        setState(524);
        match(LcypherParser::T__4);
        break;
      }

      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::HexLetter:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        setState(525);
        oC_YieldItem();
        setState(536);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(527);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(526);
              match(LcypherParser::SP);
            }
            setState(529);
            match(LcypherParser::T__1);
            setState(531);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(530);
              match(LcypherParser::SP);
            }
            setState(533);
            oC_YieldItem(); 
          }
          setState(538);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(545);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 72, _ctx)) {
    case 1: {
      setState(542);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(541);
        match(LcypherParser::SP);
      }
      setState(544);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_YieldItemContext ------------------------------------------------------------------

LcypherParser::OC_YieldItemContext::OC_YieldItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_VariableContext* LcypherParser::OC_YieldItemContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_ProcedureResultFieldContext* LcypherParser::OC_YieldItemContext::oC_ProcedureResultField() {
  return getRuleContext<LcypherParser::OC_ProcedureResultFieldContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_YieldItemContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_YieldItemContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_YieldItemContext::AS() {
  return getToken(LcypherParser::AS, 0);
}


size_t LcypherParser::OC_YieldItemContext::getRuleIndex() const {
  return LcypherParser::RuleOC_YieldItem;
}


std::any LcypherParser::OC_YieldItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_YieldItem(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_YieldItemContext* LcypherParser::oC_YieldItem() {
  OC_YieldItemContext *_localctx = _tracker.createInstance<OC_YieldItemContext>(_ctx, getState());
  enterRule(_localctx, 46, LcypherParser::RuleOC_YieldItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(552);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
    case 1: {
      setState(547);
      oC_ProcedureResultField();
      setState(548);
      match(LcypherParser::SP);
      setState(549);
      match(LcypherParser::AS);
      setState(550);
      match(LcypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(554);
    oC_Variable();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_WithContext ------------------------------------------------------------------

LcypherParser::OC_WithContext::OC_WithContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_WithContext::WITH() {
  return getToken(LcypherParser::WITH, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_WithContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_WithContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ReturnBodyContext* LcypherParser::OC_WithContext::oC_ReturnBody() {
  return getRuleContext<LcypherParser::OC_ReturnBodyContext>(0);
}

tree::TerminalNode* LcypherParser::OC_WithContext::DISTINCT() {
  return getToken(LcypherParser::DISTINCT, 0);
}

LcypherParser::OC_WhereContext* LcypherParser::OC_WithContext::oC_Where() {
  return getRuleContext<LcypherParser::OC_WhereContext>(0);
}


size_t LcypherParser::OC_WithContext::getRuleIndex() const {
  return LcypherParser::RuleOC_With;
}


std::any LcypherParser::OC_WithContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_With(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_WithContext* LcypherParser::oC_With() {
  OC_WithContext *_localctx = _tracker.createInstance<OC_WithContext>(_ctx, getState());
  enterRule(_localctx, 48, LcypherParser::RuleOC_With);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(556);
    match(LcypherParser::WITH);
    setState(561);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
    case 1: {
      setState(558);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(557);
        match(LcypherParser::SP);
      }
      setState(560);
      match(LcypherParser::DISTINCT);
      break;
    }

    default:
      break;
    }
    setState(563);
    match(LcypherParser::SP);
    setState(564);
    oC_ReturnBody();
    setState(569);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 77, _ctx)) {
    case 1: {
      setState(566);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(565);
        match(LcypherParser::SP);
      }
      setState(568);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReturnContext ------------------------------------------------------------------

LcypherParser::OC_ReturnContext::OC_ReturnContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_ReturnContext::RETURN() {
  return getToken(LcypherParser::RETURN, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ReturnContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ReturnContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ReturnBodyContext* LcypherParser::OC_ReturnContext::oC_ReturnBody() {
  return getRuleContext<LcypherParser::OC_ReturnBodyContext>(0);
}

tree::TerminalNode* LcypherParser::OC_ReturnContext::DISTINCT() {
  return getToken(LcypherParser::DISTINCT, 0);
}


size_t LcypherParser::OC_ReturnContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Return;
}


std::any LcypherParser::OC_ReturnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Return(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReturnContext* LcypherParser::oC_Return() {
  OC_ReturnContext *_localctx = _tracker.createInstance<OC_ReturnContext>(_ctx, getState());
  enterRule(_localctx, 50, LcypherParser::RuleOC_Return);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(571);
    match(LcypherParser::RETURN);
    setState(576);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
    case 1: {
      setState(573);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(572);
        match(LcypherParser::SP);
      }
      setState(575);
      match(LcypherParser::DISTINCT);
      break;
    }

    default:
      break;
    }
    setState(578);
    match(LcypherParser::SP);
    setState(579);
    oC_ReturnBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReturnBodyContext ------------------------------------------------------------------

LcypherParser::OC_ReturnBodyContext::OC_ReturnBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ReturnItemsContext* LcypherParser::OC_ReturnBodyContext::oC_ReturnItems() {
  return getRuleContext<LcypherParser::OC_ReturnItemsContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ReturnBodyContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ReturnBodyContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_OrderContext* LcypherParser::OC_ReturnBodyContext::oC_Order() {
  return getRuleContext<LcypherParser::OC_OrderContext>(0);
}

LcypherParser::OC_SkipContext* LcypherParser::OC_ReturnBodyContext::oC_Skip() {
  return getRuleContext<LcypherParser::OC_SkipContext>(0);
}

LcypherParser::OC_LimitContext* LcypherParser::OC_ReturnBodyContext::oC_Limit() {
  return getRuleContext<LcypherParser::OC_LimitContext>(0);
}


size_t LcypherParser::OC_ReturnBodyContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ReturnBody;
}


std::any LcypherParser::OC_ReturnBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ReturnBody(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReturnBodyContext* LcypherParser::oC_ReturnBody() {
  OC_ReturnBodyContext *_localctx = _tracker.createInstance<OC_ReturnBodyContext>(_ctx, getState());
  enterRule(_localctx, 52, LcypherParser::RuleOC_ReturnBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(581);
    oC_ReturnItems();
    setState(584);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx)) {
    case 1: {
      setState(582);
      match(LcypherParser::SP);
      setState(583);
      oC_Order();
      break;
    }

    default:
      break;
    }
    setState(588);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx)) {
    case 1: {
      setState(586);
      match(LcypherParser::SP);
      setState(587);
      oC_Skip();
      break;
    }

    default:
      break;
    }
    setState(592);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
    case 1: {
      setState(590);
      match(LcypherParser::SP);
      setState(591);
      oC_Limit();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReturnItemsContext ------------------------------------------------------------------

LcypherParser::OC_ReturnItemsContext::OC_ReturnItemsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_ReturnItemContext *> LcypherParser::OC_ReturnItemsContext::oC_ReturnItem() {
  return getRuleContexts<LcypherParser::OC_ReturnItemContext>();
}

LcypherParser::OC_ReturnItemContext* LcypherParser::OC_ReturnItemsContext::oC_ReturnItem(size_t i) {
  return getRuleContext<LcypherParser::OC_ReturnItemContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ReturnItemsContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ReturnItemsContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_ReturnItemsContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ReturnItems;
}


std::any LcypherParser::OC_ReturnItemsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ReturnItems(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReturnItemsContext* LcypherParser::oC_ReturnItems() {
  OC_ReturnItemsContext *_localctx = _tracker.createInstance<OC_ReturnItemsContext>(_ctx, getState());
  enterRule(_localctx, 54, LcypherParser::RuleOC_ReturnItems);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(622);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::T__4: {
        enterOuterAlt(_localctx, 1);
        setState(594);
        match(LcypherParser::T__4);
        setState(605);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(596);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(595);
              match(LcypherParser::SP);
            }
            setState(598);
            match(LcypherParser::T__1);
            setState(600);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(599);
              match(LcypherParser::SP);
            }
            setState(602);
            oC_ReturnItem(); 
          }
          setState(607);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx);
        }
        break;
      }

      case LcypherParser::T__5:
      case LcypherParser::T__7:
      case LcypherParser::T__12:
      case LcypherParser::T__13:
      case LcypherParser::T__23:
      case LcypherParser::T__25:
      case LcypherParser::ALL:
      case LcypherParser::NOT:
      case LcypherParser::NULL_:
      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::TRUE_:
      case LcypherParser::FALSE_:
      case LcypherParser::EXISTS:
      case LcypherParser::CASE:
      case LcypherParser::StringLiteral:
      case LcypherParser::HexInteger:
      case LcypherParser::DecimalInteger:
      case LcypherParser::OctalInteger:
      case LcypherParser::HexLetter:
      case LcypherParser::ExponentDecimalReal:
      case LcypherParser::RegularDecimalReal:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(608);
        oC_ReturnItem();
        setState(619);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(610);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(609);
              match(LcypherParser::SP);
            }
            setState(612);
            match(LcypherParser::T__1);
            setState(614);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == LcypherParser::SP) {
              setState(613);
              match(LcypherParser::SP);
            }
            setState(616);
            oC_ReturnItem(); 
          }
          setState(621);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReturnItemContext ------------------------------------------------------------------

LcypherParser::OC_ReturnItemContext::OC_ReturnItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ReturnItemContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ReturnItemContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ReturnItemContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_ReturnItemContext::AS() {
  return getToken(LcypherParser::AS, 0);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_ReturnItemContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}


size_t LcypherParser::OC_ReturnItemContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ReturnItem;
}


std::any LcypherParser::OC_ReturnItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ReturnItem(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReturnItemContext* LcypherParser::oC_ReturnItem() {
  OC_ReturnItemContext *_localctx = _tracker.createInstance<OC_ReturnItemContext>(_ctx, getState());
  enterRule(_localctx, 56, LcypherParser::RuleOC_ReturnItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(631);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(624);
      oC_Expression();
      setState(625);
      match(LcypherParser::SP);
      setState(626);
      match(LcypherParser::AS);
      setState(627);
      match(LcypherParser::SP);
      setState(628);
      oC_Variable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(630);
      oC_Expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_OrderContext ------------------------------------------------------------------

LcypherParser::OC_OrderContext::OC_OrderContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_OrderContext::ORDER() {
  return getToken(LcypherParser::ORDER, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_OrderContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_OrderContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_OrderContext::BY() {
  return getToken(LcypherParser::BY, 0);
}

std::vector<LcypherParser::OC_SortItemContext *> LcypherParser::OC_OrderContext::oC_SortItem() {
  return getRuleContexts<LcypherParser::OC_SortItemContext>();
}

LcypherParser::OC_SortItemContext* LcypherParser::OC_OrderContext::oC_SortItem(size_t i) {
  return getRuleContext<LcypherParser::OC_SortItemContext>(i);
}


size_t LcypherParser::OC_OrderContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Order;
}


std::any LcypherParser::OC_OrderContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Order(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_OrderContext* LcypherParser::oC_Order() {
  OC_OrderContext *_localctx = _tracker.createInstance<OC_OrderContext>(_ctx, getState());
  enterRule(_localctx, 58, LcypherParser::RuleOC_Order);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(633);
    match(LcypherParser::ORDER);
    setState(634);
    match(LcypherParser::SP);
    setState(635);
    match(LcypherParser::BY);
    setState(636);
    match(LcypherParser::SP);
    setState(637);
    oC_SortItem();
    setState(645);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == LcypherParser::T__1) {
      setState(638);
      match(LcypherParser::T__1);
      setState(640);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(639);
        match(LcypherParser::SP);
      }
      setState(642);
      oC_SortItem();
      setState(647);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SkipContext ------------------------------------------------------------------

LcypherParser::OC_SkipContext::OC_SkipContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_SkipContext::L_SKIP() {
  return getToken(LcypherParser::L_SKIP, 0);
}

tree::TerminalNode* LcypherParser::OC_SkipContext::SP() {
  return getToken(LcypherParser::SP, 0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_SkipContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}


size_t LcypherParser::OC_SkipContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Skip;
}


std::any LcypherParser::OC_SkipContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Skip(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SkipContext* LcypherParser::oC_Skip() {
  OC_SkipContext *_localctx = _tracker.createInstance<OC_SkipContext>(_ctx, getState());
  enterRule(_localctx, 60, LcypherParser::RuleOC_Skip);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(648);
    match(LcypherParser::L_SKIP);
    setState(649);
    match(LcypherParser::SP);
    setState(650);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LimitContext ------------------------------------------------------------------

LcypherParser::OC_LimitContext::OC_LimitContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_LimitContext::LIMIT() {
  return getToken(LcypherParser::LIMIT, 0);
}

tree::TerminalNode* LcypherParser::OC_LimitContext::SP() {
  return getToken(LcypherParser::SP, 0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_LimitContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}


size_t LcypherParser::OC_LimitContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Limit;
}


std::any LcypherParser::OC_LimitContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Limit(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_LimitContext* LcypherParser::oC_Limit() {
  OC_LimitContext *_localctx = _tracker.createInstance<OC_LimitContext>(_ctx, getState());
  enterRule(_localctx, 62, LcypherParser::RuleOC_Limit);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(652);
    match(LcypherParser::LIMIT);
    setState(653);
    match(LcypherParser::SP);
    setState(654);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SortItemContext ------------------------------------------------------------------

LcypherParser::OC_SortItemContext::OC_SortItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_SortItemContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}

tree::TerminalNode* LcypherParser::OC_SortItemContext::ASCENDING() {
  return getToken(LcypherParser::ASCENDING, 0);
}

tree::TerminalNode* LcypherParser::OC_SortItemContext::ASC() {
  return getToken(LcypherParser::ASC, 0);
}

tree::TerminalNode* LcypherParser::OC_SortItemContext::DESCENDING() {
  return getToken(LcypherParser::DESCENDING, 0);
}

tree::TerminalNode* LcypherParser::OC_SortItemContext::DESC() {
  return getToken(LcypherParser::DESC, 0);
}

tree::TerminalNode* LcypherParser::OC_SortItemContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_SortItemContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SortItem;
}


std::any LcypherParser::OC_SortItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SortItem(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SortItemContext* LcypherParser::oC_SortItem() {
  OC_SortItemContext *_localctx = _tracker.createInstance<OC_SortItemContext>(_ctx, getState());
  enterRule(_localctx, 64, LcypherParser::RuleOC_SortItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(656);
    oC_Expression();
    setState(661);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx)) {
    case 1: {
      setState(658);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(657);
        match(LcypherParser::SP);
      }
      setState(660);
      _la = _input->LA(1);
      if (!(((((_la - 70) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 70)) & 15) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_HintContext ------------------------------------------------------------------

LcypherParser::OC_HintContext::OC_HintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_HintContext::USING() {
  return getToken(LcypherParser::USING, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_HintContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_HintContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_HintContext::JOIN() {
  return getToken(LcypherParser::JOIN, 0);
}

tree::TerminalNode* LcypherParser::OC_HintContext::ON() {
  return getToken(LcypherParser::ON, 0);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_HintContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

tree::TerminalNode* LcypherParser::OC_HintContext::START() {
  return getToken(LcypherParser::START, 0);
}


size_t LcypherParser::OC_HintContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Hint;
}


std::any LcypherParser::OC_HintContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Hint(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_HintContext* LcypherParser::oC_Hint() {
  OC_HintContext *_localctx = _tracker.createInstance<OC_HintContext>(_ctx, getState());
  enterRule(_localctx, 66, LcypherParser::RuleOC_Hint);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(677);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(663);
      match(LcypherParser::USING);
      setState(664);
      match(LcypherParser::SP);
      setState(665);
      match(LcypherParser::JOIN);
      setState(666);
      match(LcypherParser::SP);
      setState(667);
      match(LcypherParser::ON);
      setState(668);
      match(LcypherParser::SP);
      setState(669);
      oC_Variable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(670);
      match(LcypherParser::USING);
      setState(671);
      match(LcypherParser::SP);
      setState(672);
      match(LcypherParser::START);
      setState(673);
      match(LcypherParser::SP);
      setState(674);
      match(LcypherParser::ON);
      setState(675);
      match(LcypherParser::SP);
      setState(676);
      oC_Variable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_WhereContext ------------------------------------------------------------------

LcypherParser::OC_WhereContext::OC_WhereContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_WhereContext::WHERE() {
  return getToken(LcypherParser::WHERE, 0);
}

tree::TerminalNode* LcypherParser::OC_WhereContext::SP() {
  return getToken(LcypherParser::SP, 0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_WhereContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}


size_t LcypherParser::OC_WhereContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Where;
}


std::any LcypherParser::OC_WhereContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Where(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_WhereContext* LcypherParser::oC_Where() {
  OC_WhereContext *_localctx = _tracker.createInstance<OC_WhereContext>(_ctx, getState());
  enterRule(_localctx, 68, LcypherParser::RuleOC_Where);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(679);
    match(LcypherParser::WHERE);
    setState(680);
    match(LcypherParser::SP);
    setState(681);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternContext ------------------------------------------------------------------

LcypherParser::OC_PatternContext::OC_PatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_PatternPartContext *> LcypherParser::OC_PatternContext::oC_PatternPart() {
  return getRuleContexts<LcypherParser::OC_PatternPartContext>();
}

LcypherParser::OC_PatternPartContext* LcypherParser::OC_PatternContext::oC_PatternPart(size_t i) {
  return getRuleContext<LcypherParser::OC_PatternPartContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PatternContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PatternContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_PatternContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Pattern;
}


std::any LcypherParser::OC_PatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Pattern(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PatternContext* LcypherParser::oC_Pattern() {
  OC_PatternContext *_localctx = _tracker.createInstance<OC_PatternContext>(_ctx, getState());
  enterRule(_localctx, 70, LcypherParser::RuleOC_Pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(683);
    oC_PatternPart();
    setState(694);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(685);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(684);
          match(LcypherParser::SP);
        }
        setState(687);
        match(LcypherParser::T__1);
        setState(689);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(688);
          match(LcypherParser::SP);
        }
        setState(691);
        oC_PatternPart(); 
      }
      setState(696);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternPartContext ------------------------------------------------------------------

LcypherParser::OC_PatternPartContext::OC_PatternPartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_VariableContext* LcypherParser::OC_PatternPartContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_AnonymousPatternPartContext* LcypherParser::OC_PatternPartContext::oC_AnonymousPatternPart() {
  return getRuleContext<LcypherParser::OC_AnonymousPatternPartContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PatternPartContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PatternPartContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_PatternPartContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PatternPart;
}


std::any LcypherParser::OC_PatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PatternPart(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PatternPartContext* LcypherParser::oC_PatternPart() {
  OC_PatternPartContext *_localctx = _tracker.createInstance<OC_PatternPartContext>(_ctx, getState());
  enterRule(_localctx, 72, LcypherParser::RuleOC_PatternPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(708);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::HexLetter:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(697);
        oC_Variable();
        setState(699);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(698);
          match(LcypherParser::SP);
        }
        setState(701);
        match(LcypherParser::T__2);
        setState(703);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(702);
          match(LcypherParser::SP);
        }
        setState(705);
        oC_AnonymousPatternPart();
        break;
      }

      case LcypherParser::T__5: {
        enterOuterAlt(_localctx, 2);
        setState(707);
        oC_AnonymousPatternPart();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AnonymousPatternPartContext ------------------------------------------------------------------

LcypherParser::OC_AnonymousPatternPartContext::OC_AnonymousPatternPartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_PatternElementContext* LcypherParser::OC_AnonymousPatternPartContext::oC_PatternElement() {
  return getRuleContext<LcypherParser::OC_PatternElementContext>(0);
}


size_t LcypherParser::OC_AnonymousPatternPartContext::getRuleIndex() const {
  return LcypherParser::RuleOC_AnonymousPatternPart;
}


std::any LcypherParser::OC_AnonymousPatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_AnonymousPatternPart(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_AnonymousPatternPartContext* LcypherParser::oC_AnonymousPatternPart() {
  OC_AnonymousPatternPartContext *_localctx = _tracker.createInstance<OC_AnonymousPatternPartContext>(_ctx, getState());
  enterRule(_localctx, 74, LcypherParser::RuleOC_AnonymousPatternPart);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(710);
    oC_PatternElement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternElementContext ------------------------------------------------------------------

LcypherParser::OC_PatternElementContext::OC_PatternElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_NodePatternContext* LcypherParser::OC_PatternElementContext::oC_NodePattern() {
  return getRuleContext<LcypherParser::OC_NodePatternContext>(0);
}

std::vector<LcypherParser::OC_PatternElementChainContext *> LcypherParser::OC_PatternElementContext::oC_PatternElementChain() {
  return getRuleContexts<LcypherParser::OC_PatternElementChainContext>();
}

LcypherParser::OC_PatternElementChainContext* LcypherParser::OC_PatternElementContext::oC_PatternElementChain(size_t i) {
  return getRuleContext<LcypherParser::OC_PatternElementChainContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PatternElementContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PatternElementContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_PatternElementContext* LcypherParser::OC_PatternElementContext::oC_PatternElement() {
  return getRuleContext<LcypherParser::OC_PatternElementContext>(0);
}


size_t LcypherParser::OC_PatternElementContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PatternElement;
}


std::any LcypherParser::OC_PatternElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PatternElement(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PatternElementContext* LcypherParser::oC_PatternElement() {
  OC_PatternElementContext *_localctx = _tracker.createInstance<OC_PatternElementContext>(_ctx, getState());
  enterRule(_localctx, 76, LcypherParser::RuleOC_PatternElement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(726);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(712);
      oC_NodePattern();
      setState(719);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(714);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(713);
            match(LcypherParser::SP);
          }
          setState(716);
          oC_PatternElementChain(); 
        }
        setState(721);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(722);
      match(LcypherParser::T__5);
      setState(723);
      oC_PatternElement();
      setState(724);
      match(LcypherParser::T__6);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodePatternContext ------------------------------------------------------------------

LcypherParser::OC_NodePatternContext::OC_NodePatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_NodePatternContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_NodePatternContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_NodePatternContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_NodeLabelsContext* LcypherParser::OC_NodePatternContext::oC_NodeLabels() {
  return getRuleContext<LcypherParser::OC_NodeLabelsContext>(0);
}

LcypherParser::OC_PropertiesContext* LcypherParser::OC_NodePatternContext::oC_Properties() {
  return getRuleContext<LcypherParser::OC_PropertiesContext>(0);
}


size_t LcypherParser::OC_NodePatternContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NodePattern;
}


std::any LcypherParser::OC_NodePatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NodePattern(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NodePatternContext* LcypherParser::oC_NodePattern() {
  OC_NodePatternContext *_localctx = _tracker.createInstance<OC_NodePatternContext>(_ctx, getState());
  enterRule(_localctx, 78, LcypherParser::RuleOC_NodePattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(728);
    match(LcypherParser::T__5);
    setState(730);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(729);
      match(LcypherParser::SP);
    }
    setState(736);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 89) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 89)) & 2199493148687) != 0)) {
      setState(732);
      oC_Variable();
      setState(734);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(733);
        match(LcypherParser::SP);
      }
    }
    setState(742);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__9) {
      setState(738);
      oC_NodeLabels();
      setState(740);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(739);
        match(LcypherParser::SP);
      }
    }
    setState(748);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__23

    || _la == LcypherParser::T__25) {
      setState(744);
      oC_Properties();
      setState(746);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(745);
        match(LcypherParser::SP);
      }
    }
    setState(750);
    match(LcypherParser::T__6);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternElementChainContext ------------------------------------------------------------------

LcypherParser::OC_PatternElementChainContext::OC_PatternElementChainContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_RelationshipPatternContext* LcypherParser::OC_PatternElementChainContext::oC_RelationshipPattern() {
  return getRuleContext<LcypherParser::OC_RelationshipPatternContext>(0);
}

LcypherParser::OC_NodePatternContext* LcypherParser::OC_PatternElementChainContext::oC_NodePattern() {
  return getRuleContext<LcypherParser::OC_NodePatternContext>(0);
}

tree::TerminalNode* LcypherParser::OC_PatternElementChainContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_PatternElementChainContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PatternElementChain;
}


std::any LcypherParser::OC_PatternElementChainContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PatternElementChain(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PatternElementChainContext* LcypherParser::oC_PatternElementChain() {
  OC_PatternElementChainContext *_localctx = _tracker.createInstance<OC_PatternElementChainContext>(_ctx, getState());
  enterRule(_localctx, 80, LcypherParser::RuleOC_PatternElementChain);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(752);
    oC_RelationshipPattern();
    setState(754);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(753);
      match(LcypherParser::SP);
    }
    setState(756);
    oC_NodePattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipPatternContext ------------------------------------------------------------------

LcypherParser::OC_RelationshipPatternContext::OC_RelationshipPatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_LeftArrowHeadContext* LcypherParser::OC_RelationshipPatternContext::oC_LeftArrowHead() {
  return getRuleContext<LcypherParser::OC_LeftArrowHeadContext>(0);
}

std::vector<LcypherParser::OC_DashContext *> LcypherParser::OC_RelationshipPatternContext::oC_Dash() {
  return getRuleContexts<LcypherParser::OC_DashContext>();
}

LcypherParser::OC_DashContext* LcypherParser::OC_RelationshipPatternContext::oC_Dash(size_t i) {
  return getRuleContext<LcypherParser::OC_DashContext>(i);
}

LcypherParser::OC_RightArrowHeadContext* LcypherParser::OC_RelationshipPatternContext::oC_RightArrowHead() {
  return getRuleContext<LcypherParser::OC_RightArrowHeadContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RelationshipPatternContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RelationshipPatternContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_RelationshipDetailContext* LcypherParser::OC_RelationshipPatternContext::oC_RelationshipDetail() {
  return getRuleContext<LcypherParser::OC_RelationshipDetailContext>(0);
}


size_t LcypherParser::OC_RelationshipPatternContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RelationshipPattern;
}


std::any LcypherParser::OC_RelationshipPatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RelationshipPattern(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RelationshipPatternContext* LcypherParser::oC_RelationshipPattern() {
  OC_RelationshipPatternContext *_localctx = _tracker.createInstance<OC_RelationshipPatternContext>(_ctx, getState());
  enterRule(_localctx, 82, LcypherParser::RuleOC_RelationshipPattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(822);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(758);
      oC_LeftArrowHead();
      setState(760);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(759);
        match(LcypherParser::SP);
      }
      setState(762);
      oC_Dash();
      setState(764);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
      case 1: {
        setState(763);
        match(LcypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(767);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::T__7) {
        setState(766);
        oC_RelationshipDetail();
      }
      setState(770);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(769);
        match(LcypherParser::SP);
      }
      setState(772);
      oC_Dash();
      setState(774);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(773);
        match(LcypherParser::SP);
      }
      setState(776);
      oC_RightArrowHead();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(778);
      oC_LeftArrowHead();
      setState(780);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(779);
        match(LcypherParser::SP);
      }
      setState(782);
      oC_Dash();
      setState(784);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
      case 1: {
        setState(783);
        match(LcypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(787);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::T__7) {
        setState(786);
        oC_RelationshipDetail();
      }
      setState(790);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(789);
        match(LcypherParser::SP);
      }
      setState(792);
      oC_Dash();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(794);
      oC_Dash();
      setState(796);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 122, _ctx)) {
      case 1: {
        setState(795);
        match(LcypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(799);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::T__7) {
        setState(798);
        oC_RelationshipDetail();
      }
      setState(802);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(801);
        match(LcypherParser::SP);
      }
      setState(804);
      oC_Dash();
      setState(806);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(805);
        match(LcypherParser::SP);
      }
      setState(808);
      oC_RightArrowHead();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(810);
      oC_Dash();
      setState(812);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 126, _ctx)) {
      case 1: {
        setState(811);
        match(LcypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(815);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::T__7) {
        setState(814);
        oC_RelationshipDetail();
      }
      setState(818);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(817);
        match(LcypherParser::SP);
      }
      setState(820);
      oC_Dash();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipDetailContext ------------------------------------------------------------------

LcypherParser::OC_RelationshipDetailContext::OC_RelationshipDetailContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RelationshipDetailContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RelationshipDetailContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_RelationshipDetailContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

LcypherParser::OC_RelationshipTypesContext* LcypherParser::OC_RelationshipDetailContext::oC_RelationshipTypes() {
  return getRuleContext<LcypherParser::OC_RelationshipTypesContext>(0);
}

LcypherParser::OC_RangeLiteralContext* LcypherParser::OC_RelationshipDetailContext::oC_RangeLiteral() {
  return getRuleContext<LcypherParser::OC_RangeLiteralContext>(0);
}

LcypherParser::OC_PropertiesContext* LcypherParser::OC_RelationshipDetailContext::oC_Properties() {
  return getRuleContext<LcypherParser::OC_PropertiesContext>(0);
}


size_t LcypherParser::OC_RelationshipDetailContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RelationshipDetail;
}


std::any LcypherParser::OC_RelationshipDetailContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RelationshipDetail(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RelationshipDetailContext* LcypherParser::oC_RelationshipDetail() {
  OC_RelationshipDetailContext *_localctx = _tracker.createInstance<OC_RelationshipDetailContext>(_ctx, getState());
  enterRule(_localctx, 84, LcypherParser::RuleOC_RelationshipDetail);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(824);
    match(LcypherParser::T__7);
    setState(826);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(825);
      match(LcypherParser::SP);
    }
    setState(832);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 89) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 89)) & 2199493148687) != 0)) {
      setState(828);
      oC_Variable();
      setState(830);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(829);
        match(LcypherParser::SP);
      }
    }
    setState(838);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__9) {
      setState(834);
      oC_RelationshipTypes();
      setState(836);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(835);
        match(LcypherParser::SP);
      }
    }
    setState(841);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__4) {
      setState(840);
      oC_RangeLiteral();
    }
    setState(847);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__23

    || _la == LcypherParser::T__25) {
      setState(843);
      oC_Properties();
      setState(845);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(844);
        match(LcypherParser::SP);
      }
    }
    setState(849);
    match(LcypherParser::T__8);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertiesContext ------------------------------------------------------------------

LcypherParser::OC_PropertiesContext::OC_PropertiesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_MapLiteralContext* LcypherParser::OC_PropertiesContext::oC_MapLiteral() {
  return getRuleContext<LcypherParser::OC_MapLiteralContext>(0);
}

LcypherParser::OC_ParameterContext* LcypherParser::OC_PropertiesContext::oC_Parameter() {
  return getRuleContext<LcypherParser::OC_ParameterContext>(0);
}


size_t LcypherParser::OC_PropertiesContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Properties;
}


std::any LcypherParser::OC_PropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Properties(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PropertiesContext* LcypherParser::oC_Properties() {
  OC_PropertiesContext *_localctx = _tracker.createInstance<OC_PropertiesContext>(_ctx, getState());
  enterRule(_localctx, 86, LcypherParser::RuleOC_Properties);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(853);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::T__23: {
        enterOuterAlt(_localctx, 1);
        setState(851);
        oC_MapLiteral();
        break;
      }

      case LcypherParser::T__25: {
        enterOuterAlt(_localctx, 2);
        setState(852);
        oC_Parameter();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipTypesContext ------------------------------------------------------------------

LcypherParser::OC_RelationshipTypesContext::OC_RelationshipTypesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_RelTypeNameContext *> LcypherParser::OC_RelationshipTypesContext::oC_RelTypeName() {
  return getRuleContexts<LcypherParser::OC_RelTypeNameContext>();
}

LcypherParser::OC_RelTypeNameContext* LcypherParser::OC_RelationshipTypesContext::oC_RelTypeName(size_t i) {
  return getRuleContext<LcypherParser::OC_RelTypeNameContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RelationshipTypesContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RelationshipTypesContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_RelationshipTypesContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RelationshipTypes;
}


std::any LcypherParser::OC_RelationshipTypesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RelationshipTypes(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RelationshipTypesContext* LcypherParser::oC_RelationshipTypes() {
  OC_RelationshipTypesContext *_localctx = _tracker.createInstance<OC_RelationshipTypesContext>(_ctx, getState());
  enterRule(_localctx, 88, LcypherParser::RuleOC_RelationshipTypes);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(855);
    match(LcypherParser::T__9);
    setState(857);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(856);
      match(LcypherParser::SP);
    }
    setState(859);
    oC_RelTypeName();
    setState(873);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(861);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(860);
          match(LcypherParser::SP);
        }
        setState(863);
        match(LcypherParser::T__10);
        setState(865);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::T__9) {
          setState(864);
          match(LcypherParser::T__9);
        }
        setState(868);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(867);
          match(LcypherParser::SP);
        }
        setState(870);
        oC_RelTypeName(); 
      }
      setState(875);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodeLabelsContext ------------------------------------------------------------------

LcypherParser::OC_NodeLabelsContext::OC_NodeLabelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_NodeLabelContext *> LcypherParser::OC_NodeLabelsContext::oC_NodeLabel() {
  return getRuleContexts<LcypherParser::OC_NodeLabelContext>();
}

LcypherParser::OC_NodeLabelContext* LcypherParser::OC_NodeLabelsContext::oC_NodeLabel(size_t i) {
  return getRuleContext<LcypherParser::OC_NodeLabelContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_NodeLabelsContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_NodeLabelsContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_NodeLabelsContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NodeLabels;
}


std::any LcypherParser::OC_NodeLabelsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NodeLabels(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NodeLabelsContext* LcypherParser::oC_NodeLabels() {
  OC_NodeLabelsContext *_localctx = _tracker.createInstance<OC_NodeLabelsContext>(_ctx, getState());
  enterRule(_localctx, 90, LcypherParser::RuleOC_NodeLabels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(876);
    oC_NodeLabel();
    setState(883);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(878);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(877);
          match(LcypherParser::SP);
        }
        setState(880);
        oC_NodeLabel(); 
      }
      setState(885);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodeLabelContext ------------------------------------------------------------------

LcypherParser::OC_NodeLabelContext::OC_NodeLabelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_LabelNameContext* LcypherParser::OC_NodeLabelContext::oC_LabelName() {
  return getRuleContext<LcypherParser::OC_LabelNameContext>(0);
}

tree::TerminalNode* LcypherParser::OC_NodeLabelContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_NodeLabelContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NodeLabel;
}


std::any LcypherParser::OC_NodeLabelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NodeLabel(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NodeLabelContext* LcypherParser::oC_NodeLabel() {
  OC_NodeLabelContext *_localctx = _tracker.createInstance<OC_NodeLabelContext>(_ctx, getState());
  enterRule(_localctx, 92, LcypherParser::RuleOC_NodeLabel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(886);
    match(LcypherParser::T__9);
    setState(888);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(887);
      match(LcypherParser::SP);
    }
    setState(890);
    oC_LabelName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RangeLiteralContext ------------------------------------------------------------------

LcypherParser::OC_RangeLiteralContext::OC_RangeLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RangeLiteralContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RangeLiteralContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_IntegerLiteralContext *> LcypherParser::OC_RangeLiteralContext::oC_IntegerLiteral() {
  return getRuleContexts<LcypherParser::OC_IntegerLiteralContext>();
}

LcypherParser::OC_IntegerLiteralContext* LcypherParser::OC_RangeLiteralContext::oC_IntegerLiteral(size_t i) {
  return getRuleContext<LcypherParser::OC_IntegerLiteralContext>(i);
}


size_t LcypherParser::OC_RangeLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RangeLiteral;
}


std::any LcypherParser::OC_RangeLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RangeLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RangeLiteralContext* LcypherParser::oC_RangeLiteral() {
  OC_RangeLiteralContext *_localctx = _tracker.createInstance<OC_RangeLiteralContext>(_ctx, getState());
  enterRule(_localctx, 94, LcypherParser::RuleOC_RangeLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(892);
    match(LcypherParser::T__4);
    setState(894);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(893);
      match(LcypherParser::SP);
    }
    setState(900);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 103) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 103)) & 7) != 0)) {
      setState(896);
      oC_IntegerLiteral();
      setState(898);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(897);
        match(LcypherParser::SP);
      }
    }
    setState(912);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::T__11) {
      setState(902);
      match(LcypherParser::T__11);
      setState(904);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(903);
        match(LcypherParser::SP);
      }
      setState(910);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 103) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 103)) & 7) != 0)) {
        setState(906);
        oC_IntegerLiteral();
        setState(908);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(907);
          match(LcypherParser::SP);
        }
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LabelNameContext ------------------------------------------------------------------

LcypherParser::OC_LabelNameContext::OC_LabelNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SchemaNameContext* LcypherParser::OC_LabelNameContext::oC_SchemaName() {
  return getRuleContext<LcypherParser::OC_SchemaNameContext>(0);
}


size_t LcypherParser::OC_LabelNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_LabelName;
}


std::any LcypherParser::OC_LabelNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_LabelName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_LabelNameContext* LcypherParser::oC_LabelName() {
  OC_LabelNameContext *_localctx = _tracker.createInstance<OC_LabelNameContext>(_ctx, getState());
  enterRule(_localctx, 96, LcypherParser::RuleOC_LabelName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(914);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelTypeNameContext ------------------------------------------------------------------

LcypherParser::OC_RelTypeNameContext::OC_RelTypeNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SchemaNameContext* LcypherParser::OC_RelTypeNameContext::oC_SchemaName() {
  return getRuleContext<LcypherParser::OC_SchemaNameContext>(0);
}


size_t LcypherParser::OC_RelTypeNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RelTypeName;
}


std::any LcypherParser::OC_RelTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RelTypeName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RelTypeNameContext* LcypherParser::oC_RelTypeName() {
  OC_RelTypeNameContext *_localctx = _tracker.createInstance<OC_RelTypeNameContext>(_ctx, getState());
  enterRule(_localctx, 98, LcypherParser::RuleOC_RelTypeName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(916);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ExpressionContext ------------------------------------------------------------------

LcypherParser::OC_ExpressionContext::OC_ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_OrExpressionContext* LcypherParser::OC_ExpressionContext::oC_OrExpression() {
  return getRuleContext<LcypherParser::OC_OrExpressionContext>(0);
}


size_t LcypherParser::OC_ExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Expression;
}


std::any LcypherParser::OC_ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Expression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ExpressionContext* LcypherParser::oC_Expression() {
  OC_ExpressionContext *_localctx = _tracker.createInstance<OC_ExpressionContext>(_ctx, getState());
  enterRule(_localctx, 100, LcypherParser::RuleOC_Expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(918);
    oC_OrExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_OrExpressionContext ------------------------------------------------------------------

LcypherParser::OC_OrExpressionContext::OC_OrExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_XorExpressionContext *> LcypherParser::OC_OrExpressionContext::oC_XorExpression() {
  return getRuleContexts<LcypherParser::OC_XorExpressionContext>();
}

LcypherParser::OC_XorExpressionContext* LcypherParser::OC_OrExpressionContext::oC_XorExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_XorExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_OrExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_OrExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_OrExpressionContext::OR() {
  return getTokens(LcypherParser::OR);
}

tree::TerminalNode* LcypherParser::OC_OrExpressionContext::OR(size_t i) {
  return getToken(LcypherParser::OR, i);
}


size_t LcypherParser::OC_OrExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_OrExpression;
}


std::any LcypherParser::OC_OrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_OrExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_OrExpressionContext* LcypherParser::oC_OrExpression() {
  OC_OrExpressionContext *_localctx = _tracker.createInstance<OC_OrExpressionContext>(_ctx, getState());
  enterRule(_localctx, 102, LcypherParser::RuleOC_OrExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(920);
    oC_XorExpression();
    setState(927);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(921);
        match(LcypherParser::SP);
        setState(922);
        match(LcypherParser::OR);
        setState(923);
        match(LcypherParser::SP);
        setState(924);
        oC_XorExpression(); 
      }
      setState(929);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_XorExpressionContext ------------------------------------------------------------------

LcypherParser::OC_XorExpressionContext::OC_XorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_AndExpressionContext *> LcypherParser::OC_XorExpressionContext::oC_AndExpression() {
  return getRuleContexts<LcypherParser::OC_AndExpressionContext>();
}

LcypherParser::OC_AndExpressionContext* LcypherParser::OC_XorExpressionContext::oC_AndExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_AndExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_XorExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_XorExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_XorExpressionContext::XOR() {
  return getTokens(LcypherParser::XOR);
}

tree::TerminalNode* LcypherParser::OC_XorExpressionContext::XOR(size_t i) {
  return getToken(LcypherParser::XOR, i);
}


size_t LcypherParser::OC_XorExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_XorExpression;
}


std::any LcypherParser::OC_XorExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_XorExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_XorExpressionContext* LcypherParser::oC_XorExpression() {
  OC_XorExpressionContext *_localctx = _tracker.createInstance<OC_XorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 104, LcypherParser::RuleOC_XorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(930);
    oC_AndExpression();
    setState(937);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(931);
        match(LcypherParser::SP);
        setState(932);
        match(LcypherParser::XOR);
        setState(933);
        match(LcypherParser::SP);
        setState(934);
        oC_AndExpression(); 
      }
      setState(939);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AndExpressionContext ------------------------------------------------------------------

LcypherParser::OC_AndExpressionContext::OC_AndExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_NotExpressionContext *> LcypherParser::OC_AndExpressionContext::oC_NotExpression() {
  return getRuleContexts<LcypherParser::OC_NotExpressionContext>();
}

LcypherParser::OC_NotExpressionContext* LcypherParser::OC_AndExpressionContext::oC_NotExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_NotExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_AndExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_AndExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_AndExpressionContext::AND() {
  return getTokens(LcypherParser::AND);
}

tree::TerminalNode* LcypherParser::OC_AndExpressionContext::AND(size_t i) {
  return getToken(LcypherParser::AND, i);
}


size_t LcypherParser::OC_AndExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_AndExpression;
}


std::any LcypherParser::OC_AndExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_AndExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_AndExpressionContext* LcypherParser::oC_AndExpression() {
  OC_AndExpressionContext *_localctx = _tracker.createInstance<OC_AndExpressionContext>(_ctx, getState());
  enterRule(_localctx, 106, LcypherParser::RuleOC_AndExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(940);
    oC_NotExpression();
    setState(947);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(941);
        match(LcypherParser::SP);
        setState(942);
        match(LcypherParser::AND);
        setState(943);
        match(LcypherParser::SP);
        setState(944);
        oC_NotExpression(); 
      }
      setState(949);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NotExpressionContext ------------------------------------------------------------------

LcypherParser::OC_NotExpressionContext::OC_NotExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ComparisonExpressionContext* LcypherParser::OC_NotExpressionContext::oC_ComparisonExpression() {
  return getRuleContext<LcypherParser::OC_ComparisonExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_NotExpressionContext::NOT() {
  return getTokens(LcypherParser::NOT);
}

tree::TerminalNode* LcypherParser::OC_NotExpressionContext::NOT(size_t i) {
  return getToken(LcypherParser::NOT, i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_NotExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_NotExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_NotExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NotExpression;
}


std::any LcypherParser::OC_NotExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NotExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NotExpressionContext* LcypherParser::oC_NotExpression() {
  OC_NotExpressionContext *_localctx = _tracker.createInstance<OC_NotExpressionContext>(_ctx, getState());
  enterRule(_localctx, 108, LcypherParser::RuleOC_NotExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(956);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == LcypherParser::NOT) {
      setState(950);
      match(LcypherParser::NOT);
      setState(952);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(951);
        match(LcypherParser::SP);
      }
      setState(958);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(959);
    oC_ComparisonExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ComparisonExpressionContext ------------------------------------------------------------------

LcypherParser::OC_ComparisonExpressionContext::OC_ComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_AddOrSubtractExpressionContext* LcypherParser::OC_ComparisonExpressionContext::oC_AddOrSubtractExpression() {
  return getRuleContext<LcypherParser::OC_AddOrSubtractExpressionContext>(0);
}

std::vector<LcypherParser::OC_PartialComparisonExpressionContext *> LcypherParser::OC_ComparisonExpressionContext::oC_PartialComparisonExpression() {
  return getRuleContexts<LcypherParser::OC_PartialComparisonExpressionContext>();
}

LcypherParser::OC_PartialComparisonExpressionContext* LcypherParser::OC_ComparisonExpressionContext::oC_PartialComparisonExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_PartialComparisonExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ComparisonExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ComparisonExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_ComparisonExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ComparisonExpression;
}


std::any LcypherParser::OC_ComparisonExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ComparisonExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ComparisonExpressionContext* LcypherParser::oC_ComparisonExpression() {
  OC_ComparisonExpressionContext *_localctx = _tracker.createInstance<OC_ComparisonExpressionContext>(_ctx, getState());
  enterRule(_localctx, 110, LcypherParser::RuleOC_ComparisonExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(961);
    oC_AddOrSubtractExpression();
    setState(968);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(963);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(962);
          match(LcypherParser::SP);
        }
        setState(965);
        oC_PartialComparisonExpression(); 
      }
      setState(970);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AddOrSubtractExpressionContext ------------------------------------------------------------------

LcypherParser::OC_AddOrSubtractExpressionContext::OC_AddOrSubtractExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_MultiplyDivideModuloExpressionContext *> LcypherParser::OC_AddOrSubtractExpressionContext::oC_MultiplyDivideModuloExpression() {
  return getRuleContexts<LcypherParser::OC_MultiplyDivideModuloExpressionContext>();
}

LcypherParser::OC_MultiplyDivideModuloExpressionContext* LcypherParser::OC_AddOrSubtractExpressionContext::oC_MultiplyDivideModuloExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_MultiplyDivideModuloExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_AddOrSubtractExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_AddOrSubtractExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_AddOrSubtractExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_AddOrSubtractExpression;
}


std::any LcypherParser::OC_AddOrSubtractExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_AddOrSubtractExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_AddOrSubtractExpressionContext* LcypherParser::oC_AddOrSubtractExpression() {
  OC_AddOrSubtractExpressionContext *_localctx = _tracker.createInstance<OC_AddOrSubtractExpressionContext>(_ctx, getState());
  enterRule(_localctx, 112, LcypherParser::RuleOC_AddOrSubtractExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(971);
    oC_MultiplyDivideModuloExpression();
    setState(990);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 166, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(988);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
        case 1: {
          setState(973);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(972);
            match(LcypherParser::SP);
          }
          setState(975);
          match(LcypherParser::T__12);
          setState(977);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(976);
            match(LcypherParser::SP);
          }
          setState(979);
          oC_MultiplyDivideModuloExpression();
          break;
        }

        case 2: {
          setState(981);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(980);
            match(LcypherParser::SP);
          }
          setState(983);
          match(LcypherParser::T__13);
          setState(985);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(984);
            match(LcypherParser::SP);
          }
          setState(987);
          oC_MultiplyDivideModuloExpression();
          break;
        }

        default:
          break;
        } 
      }
      setState(992);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 166, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MultiplyDivideModuloExpressionContext ------------------------------------------------------------------

LcypherParser::OC_MultiplyDivideModuloExpressionContext::OC_MultiplyDivideModuloExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_PowerOfExpressionContext *> LcypherParser::OC_MultiplyDivideModuloExpressionContext::oC_PowerOfExpression() {
  return getRuleContexts<LcypherParser::OC_PowerOfExpressionContext>();
}

LcypherParser::OC_PowerOfExpressionContext* LcypherParser::OC_MultiplyDivideModuloExpressionContext::oC_PowerOfExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_PowerOfExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MultiplyDivideModuloExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MultiplyDivideModuloExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_MultiplyDivideModuloExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_MultiplyDivideModuloExpression;
}


std::any LcypherParser::OC_MultiplyDivideModuloExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_MultiplyDivideModuloExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MultiplyDivideModuloExpressionContext* LcypherParser::oC_MultiplyDivideModuloExpression() {
  OC_MultiplyDivideModuloExpressionContext *_localctx = _tracker.createInstance<OC_MultiplyDivideModuloExpressionContext>(_ctx, getState());
  enterRule(_localctx, 114, LcypherParser::RuleOC_MultiplyDivideModuloExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(993);
    oC_PowerOfExpression();
    setState(1020);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 174, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1018);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 173, _ctx)) {
        case 1: {
          setState(995);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(994);
            match(LcypherParser::SP);
          }
          setState(997);
          match(LcypherParser::T__4);
          setState(999);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(998);
            match(LcypherParser::SP);
          }
          setState(1001);
          oC_PowerOfExpression();
          break;
        }

        case 2: {
          setState(1003);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(1002);
            match(LcypherParser::SP);
          }
          setState(1005);
          match(LcypherParser::T__14);
          setState(1007);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(1006);
            match(LcypherParser::SP);
          }
          setState(1009);
          oC_PowerOfExpression();
          break;
        }

        case 3: {
          setState(1011);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(1010);
            match(LcypherParser::SP);
          }
          setState(1013);
          match(LcypherParser::T__15);
          setState(1015);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == LcypherParser::SP) {
            setState(1014);
            match(LcypherParser::SP);
          }
          setState(1017);
          oC_PowerOfExpression();
          break;
        }

        default:
          break;
        } 
      }
      setState(1022);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 174, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PowerOfExpressionContext ------------------------------------------------------------------

LcypherParser::OC_PowerOfExpressionContext::OC_PowerOfExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_UnaryAddOrSubtractExpressionContext *> LcypherParser::OC_PowerOfExpressionContext::oC_UnaryAddOrSubtractExpression() {
  return getRuleContexts<LcypherParser::OC_UnaryAddOrSubtractExpressionContext>();
}

LcypherParser::OC_UnaryAddOrSubtractExpressionContext* LcypherParser::OC_PowerOfExpressionContext::oC_UnaryAddOrSubtractExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_UnaryAddOrSubtractExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PowerOfExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PowerOfExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_PowerOfExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PowerOfExpression;
}


std::any LcypherParser::OC_PowerOfExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PowerOfExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PowerOfExpressionContext* LcypherParser::oC_PowerOfExpression() {
  OC_PowerOfExpressionContext *_localctx = _tracker.createInstance<OC_PowerOfExpressionContext>(_ctx, getState());
  enterRule(_localctx, 116, LcypherParser::RuleOC_PowerOfExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1023);
    oC_UnaryAddOrSubtractExpression();
    setState(1034);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 177, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1025);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1024);
          match(LcypherParser::SP);
        }
        setState(1027);
        match(LcypherParser::T__16);
        setState(1029);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1028);
          match(LcypherParser::SP);
        }
        setState(1031);
        oC_UnaryAddOrSubtractExpression(); 
      }
      setState(1036);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 177, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UnaryAddOrSubtractExpressionContext ------------------------------------------------------------------

LcypherParser::OC_UnaryAddOrSubtractExpressionContext::OC_UnaryAddOrSubtractExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_StringListNullOperatorExpressionContext* LcypherParser::OC_UnaryAddOrSubtractExpressionContext::oC_StringListNullOperatorExpression() {
  return getRuleContext<LcypherParser::OC_StringListNullOperatorExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_UnaryAddOrSubtractExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_UnaryAddOrSubtractExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_UnaryAddOrSubtractExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_UnaryAddOrSubtractExpression;
}


std::any LcypherParser::OC_UnaryAddOrSubtractExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_UnaryAddOrSubtractExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_UnaryAddOrSubtractExpressionContext* LcypherParser::oC_UnaryAddOrSubtractExpression() {
  OC_UnaryAddOrSubtractExpressionContext *_localctx = _tracker.createInstance<OC_UnaryAddOrSubtractExpressionContext>(_ctx, getState());
  enterRule(_localctx, 118, LcypherParser::RuleOC_UnaryAddOrSubtractExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1043);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == LcypherParser::T__12

    || _la == LcypherParser::T__13) {
      setState(1037);
      _la = _input->LA(1);
      if (!(_la == LcypherParser::T__12

      || _la == LcypherParser::T__13)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1039);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1038);
        match(LcypherParser::SP);
      }
      setState(1045);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1046);
    oC_StringListNullOperatorExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_StringListNullOperatorExpressionContext ------------------------------------------------------------------

LcypherParser::OC_StringListNullOperatorExpressionContext::OC_StringListNullOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_PropertyOrLabelsExpressionContext* LcypherParser::OC_StringListNullOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
  return getRuleContext<LcypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}

std::vector<LcypherParser::OC_StringOperatorExpressionContext *> LcypherParser::OC_StringListNullOperatorExpressionContext::oC_StringOperatorExpression() {
  return getRuleContexts<LcypherParser::OC_StringOperatorExpressionContext>();
}

LcypherParser::OC_StringOperatorExpressionContext* LcypherParser::OC_StringListNullOperatorExpressionContext::oC_StringOperatorExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_StringOperatorExpressionContext>(i);
}

std::vector<LcypherParser::OC_ListOperatorExpressionContext *> LcypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression() {
  return getRuleContexts<LcypherParser::OC_ListOperatorExpressionContext>();
}

LcypherParser::OC_ListOperatorExpressionContext* LcypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_ListOperatorExpressionContext>(i);
}

std::vector<LcypherParser::OC_NullOperatorExpressionContext *> LcypherParser::OC_StringListNullOperatorExpressionContext::oC_NullOperatorExpression() {
  return getRuleContexts<LcypherParser::OC_NullOperatorExpressionContext>();
}

LcypherParser::OC_NullOperatorExpressionContext* LcypherParser::OC_StringListNullOperatorExpressionContext::oC_NullOperatorExpression(size_t i) {
  return getRuleContext<LcypherParser::OC_NullOperatorExpressionContext>(i);
}


size_t LcypherParser::OC_StringListNullOperatorExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_StringListNullOperatorExpression;
}


std::any LcypherParser::OC_StringListNullOperatorExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_StringListNullOperatorExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_StringListNullOperatorExpressionContext* LcypherParser::oC_StringListNullOperatorExpression() {
  OC_StringListNullOperatorExpressionContext *_localctx = _tracker.createInstance<OC_StringListNullOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 120, LcypherParser::RuleOC_StringListNullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1048);
    oC_PropertyOrLabelsExpression();
    setState(1054);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1052);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
        case 1: {
          setState(1049);
          oC_StringOperatorExpression();
          break;
        }

        case 2: {
          setState(1050);
          oC_ListOperatorExpression();
          break;
        }

        case 3: {
          setState(1051);
          oC_NullOperatorExpression();
          break;
        }

        default:
          break;
        } 
      }
      setState(1056);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ListOperatorExpressionContext ------------------------------------------------------------------

LcypherParser::OC_ListOperatorExpressionContext::OC_ListOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ListOperatorExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ListOperatorExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_ListOperatorExpressionContext::IN() {
  return getToken(LcypherParser::IN, 0);
}

LcypherParser::OC_PropertyOrLabelsExpressionContext* LcypherParser::OC_ListOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
  return getRuleContext<LcypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_ListOperatorExpressionContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ListOperatorExpressionContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}


size_t LcypherParser::OC_ListOperatorExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ListOperatorExpression;
}


std::any LcypherParser::OC_ListOperatorExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ListOperatorExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ListOperatorExpressionContext* LcypherParser::oC_ListOperatorExpression() {
  OC_ListOperatorExpressionContext *_localctx = _tracker.createInstance<OC_ListOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 122, LcypherParser::RuleOC_ListOperatorExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1082);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 187, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1057);
      match(LcypherParser::SP);
      setState(1058);
      match(LcypherParser::IN);
      setState(1060);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1059);
        match(LcypherParser::SP);
      }
      setState(1062);
      oC_PropertyOrLabelsExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1064);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1063);
        match(LcypherParser::SP);
      }
      setState(1066);
      match(LcypherParser::T__7);
      setState(1067);
      oC_Expression();
      setState(1068);
      match(LcypherParser::T__8);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1071);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1070);
        match(LcypherParser::SP);
      }
      setState(1073);
      match(LcypherParser::T__7);
      setState(1075);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 562950037332288) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 81)) & 563083161436033) != 0)) {
        setState(1074);
        oC_Expression();
      }
      setState(1077);
      match(LcypherParser::T__11);
      setState(1079);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 562950037332288) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 81)) & 563083161436033) != 0)) {
        setState(1078);
        oC_Expression();
      }
      setState(1081);
      match(LcypherParser::T__8);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_StringOperatorExpressionContext ------------------------------------------------------------------

LcypherParser::OC_StringOperatorExpressionContext::OC_StringOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_PropertyOrLabelsExpressionContext* LcypherParser::OC_StringOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
  return getRuleContext<LcypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_StringOperatorExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::STARTS() {
  return getToken(LcypherParser::STARTS, 0);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::WITH() {
  return getToken(LcypherParser::WITH, 0);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::ENDS() {
  return getToken(LcypherParser::ENDS, 0);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::CONTAINS() {
  return getToken(LcypherParser::CONTAINS, 0);
}

tree::TerminalNode* LcypherParser::OC_StringOperatorExpressionContext::REGEXP() {
  return getToken(LcypherParser::REGEXP, 0);
}


size_t LcypherParser::OC_StringOperatorExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_StringOperatorExpression;
}


std::any LcypherParser::OC_StringOperatorExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_StringOperatorExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_StringOperatorExpressionContext* LcypherParser::oC_StringOperatorExpression() {
  OC_StringOperatorExpressionContext *_localctx = _tracker.createInstance<OC_StringOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 124, LcypherParser::RuleOC_StringOperatorExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1096);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 188, _ctx)) {
    case 1: {
      setState(1084);
      match(LcypherParser::SP);
      setState(1085);
      match(LcypherParser::STARTS);
      setState(1086);
      match(LcypherParser::SP);
      setState(1087);
      match(LcypherParser::WITH);
      break;
    }

    case 2: {
      setState(1088);
      match(LcypherParser::SP);
      setState(1089);
      match(LcypherParser::ENDS);
      setState(1090);
      match(LcypherParser::SP);
      setState(1091);
      match(LcypherParser::WITH);
      break;
    }

    case 3: {
      setState(1092);
      match(LcypherParser::SP);
      setState(1093);
      match(LcypherParser::CONTAINS);
      break;
    }

    case 4: {
      setState(1094);
      match(LcypherParser::SP);
      setState(1095);
      match(LcypherParser::REGEXP);
      break;
    }

    default:
      break;
    }
    setState(1099);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1098);
      match(LcypherParser::SP);
    }
    setState(1101);
    oC_PropertyOrLabelsExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NullOperatorExpressionContext ------------------------------------------------------------------

LcypherParser::OC_NullOperatorExpressionContext::OC_NullOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_NullOperatorExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_NullOperatorExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_NullOperatorExpressionContext::IS() {
  return getToken(LcypherParser::IS, 0);
}

tree::TerminalNode* LcypherParser::OC_NullOperatorExpressionContext::NULL_() {
  return getToken(LcypherParser::NULL_, 0);
}

tree::TerminalNode* LcypherParser::OC_NullOperatorExpressionContext::NOT() {
  return getToken(LcypherParser::NOT, 0);
}


size_t LcypherParser::OC_NullOperatorExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NullOperatorExpression;
}


std::any LcypherParser::OC_NullOperatorExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NullOperatorExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NullOperatorExpressionContext* LcypherParser::oC_NullOperatorExpression() {
  OC_NullOperatorExpressionContext *_localctx = _tracker.createInstance<OC_NullOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 126, LcypherParser::RuleOC_NullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1113);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 190, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1103);
      match(LcypherParser::SP);
      setState(1104);
      match(LcypherParser::IS);
      setState(1105);
      match(LcypherParser::SP);
      setState(1106);
      match(LcypherParser::NULL_);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1107);
      match(LcypherParser::SP);
      setState(1108);
      match(LcypherParser::IS);
      setState(1109);
      match(LcypherParser::SP);
      setState(1110);
      match(LcypherParser::NOT);
      setState(1111);
      match(LcypherParser::SP);
      setState(1112);
      match(LcypherParser::NULL_);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyOrLabelsExpressionContext ------------------------------------------------------------------

LcypherParser::OC_PropertyOrLabelsExpressionContext::OC_PropertyOrLabelsExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_AtomContext* LcypherParser::OC_PropertyOrLabelsExpressionContext::oC_Atom() {
  return getRuleContext<LcypherParser::OC_AtomContext>(0);
}

std::vector<LcypherParser::OC_PropertyLookupContext *> LcypherParser::OC_PropertyOrLabelsExpressionContext::oC_PropertyLookup() {
  return getRuleContexts<LcypherParser::OC_PropertyLookupContext>();
}

LcypherParser::OC_PropertyLookupContext* LcypherParser::OC_PropertyOrLabelsExpressionContext::oC_PropertyLookup(size_t i) {
  return getRuleContext<LcypherParser::OC_PropertyLookupContext>(i);
}

LcypherParser::OC_NodeLabelsContext* LcypherParser::OC_PropertyOrLabelsExpressionContext::oC_NodeLabels() {
  return getRuleContext<LcypherParser::OC_NodeLabelsContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PropertyOrLabelsExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PropertyOrLabelsExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_PropertyOrLabelsExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PropertyOrLabelsExpression;
}


std::any LcypherParser::OC_PropertyOrLabelsExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PropertyOrLabelsExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PropertyOrLabelsExpressionContext* LcypherParser::oC_PropertyOrLabelsExpression() {
  OC_PropertyOrLabelsExpressionContext *_localctx = _tracker.createInstance<OC_PropertyOrLabelsExpressionContext>(_ctx, getState());
  enterRule(_localctx, 128, LcypherParser::RuleOC_PropertyOrLabelsExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1115);
    oC_Atom();
    setState(1122);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1117);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1116);
          match(LcypherParser::SP);
        }
        setState(1119);
        oC_PropertyLookup(); 
      }
      setState(1124);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx);
    }
    setState(1129);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 194, _ctx)) {
    case 1: {
      setState(1126);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1125);
        match(LcypherParser::SP);
      }
      setState(1128);
      oC_NodeLabels();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AtomContext ------------------------------------------------------------------

LcypherParser::OC_AtomContext::OC_AtomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_LiteralContext* LcypherParser::OC_AtomContext::oC_Literal() {
  return getRuleContext<LcypherParser::OC_LiteralContext>(0);
}

LcypherParser::OC_ParameterContext* LcypherParser::OC_AtomContext::oC_Parameter() {
  return getRuleContext<LcypherParser::OC_ParameterContext>(0);
}

LcypherParser::OC_CaseExpressionContext* LcypherParser::OC_AtomContext::oC_CaseExpression() {
  return getRuleContext<LcypherParser::OC_CaseExpressionContext>(0);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::COUNT() {
  return getToken(LcypherParser::COUNT, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_AtomContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ListComprehensionContext* LcypherParser::OC_AtomContext::oC_ListComprehension() {
  return getRuleContext<LcypherParser::OC_ListComprehensionContext>(0);
}

LcypherParser::OC_PatternComprehensionContext* LcypherParser::OC_AtomContext::oC_PatternComprehension() {
  return getRuleContext<LcypherParser::OC_PatternComprehensionContext>(0);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::ALL() {
  return getToken(LcypherParser::ALL, 0);
}

LcypherParser::OC_FilterExpressionContext* LcypherParser::OC_AtomContext::oC_FilterExpression() {
  return getRuleContext<LcypherParser::OC_FilterExpressionContext>(0);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::ANY() {
  return getToken(LcypherParser::ANY, 0);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::NONE() {
  return getToken(LcypherParser::NONE, 0);
}

tree::TerminalNode* LcypherParser::OC_AtomContext::SINGLE() {
  return getToken(LcypherParser::SINGLE, 0);
}

LcypherParser::OC_RelationshipsPatternContext* LcypherParser::OC_AtomContext::oC_RelationshipsPattern() {
  return getRuleContext<LcypherParser::OC_RelationshipsPatternContext>(0);
}

LcypherParser::OC_ParenthesizedExpressionContext* LcypherParser::OC_AtomContext::oC_ParenthesizedExpression() {
  return getRuleContext<LcypherParser::OC_ParenthesizedExpressionContext>(0);
}

LcypherParser::OC_FunctionInvocationContext* LcypherParser::OC_AtomContext::oC_FunctionInvocation() {
  return getRuleContext<LcypherParser::OC_FunctionInvocationContext>(0);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_AtomContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}


size_t LcypherParser::OC_AtomContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Atom;
}


std::any LcypherParser::OC_AtomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Atom(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_AtomContext* LcypherParser::oC_Atom() {
  OC_AtomContext *_localctx = _tracker.createInstance<OC_AtomContext>(_ctx, getState());
  enterRule(_localctx, 130, LcypherParser::RuleOC_Atom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1209);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1131);
      oC_Literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1132);
      oC_Parameter();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1133);
      oC_CaseExpression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1134);
      match(LcypherParser::COUNT);
      setState(1136);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1135);
        match(LcypherParser::SP);
      }
      setState(1138);
      match(LcypherParser::T__5);
      setState(1140);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1139);
        match(LcypherParser::SP);
      }
      setState(1142);
      match(LcypherParser::T__4);
      setState(1144);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1143);
        match(LcypherParser::SP);
      }
      setState(1146);
      match(LcypherParser::T__6);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1147);
      oC_ListComprehension();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1148);
      oC_PatternComprehension();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1149);
      match(LcypherParser::ALL);
      setState(1151);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1150);
        match(LcypherParser::SP);
      }
      setState(1153);
      match(LcypherParser::T__5);
      setState(1155);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1154);
        match(LcypherParser::SP);
      }
      setState(1157);
      oC_FilterExpression();
      setState(1159);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1158);
        match(LcypherParser::SP);
      }
      setState(1161);
      match(LcypherParser::T__6);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1163);
      match(LcypherParser::ANY);
      setState(1165);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1164);
        match(LcypherParser::SP);
      }
      setState(1167);
      match(LcypherParser::T__5);
      setState(1169);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1168);
        match(LcypherParser::SP);
      }
      setState(1171);
      oC_FilterExpression();
      setState(1173);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1172);
        match(LcypherParser::SP);
      }
      setState(1175);
      match(LcypherParser::T__6);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1177);
      match(LcypherParser::NONE);
      setState(1179);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1178);
        match(LcypherParser::SP);
      }
      setState(1181);
      match(LcypherParser::T__5);
      setState(1183);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1182);
        match(LcypherParser::SP);
      }
      setState(1185);
      oC_FilterExpression();
      setState(1187);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1186);
        match(LcypherParser::SP);
      }
      setState(1189);
      match(LcypherParser::T__6);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1191);
      match(LcypherParser::SINGLE);
      setState(1193);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1192);
        match(LcypherParser::SP);
      }
      setState(1195);
      match(LcypherParser::T__5);
      setState(1197);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1196);
        match(LcypherParser::SP);
      }
      setState(1199);
      oC_FilterExpression();
      setState(1201);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1200);
        match(LcypherParser::SP);
      }
      setState(1203);
      match(LcypherParser::T__6);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1205);
      oC_RelationshipsPattern();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1206);
      oC_ParenthesizedExpression();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1207);
      oC_FunctionInvocation();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1208);
      oC_Variable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LiteralContext ------------------------------------------------------------------

LcypherParser::OC_LiteralContext::OC_LiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_NumberLiteralContext* LcypherParser::OC_LiteralContext::oC_NumberLiteral() {
  return getRuleContext<LcypherParser::OC_NumberLiteralContext>(0);
}

tree::TerminalNode* LcypherParser::OC_LiteralContext::StringLiteral() {
  return getToken(LcypherParser::StringLiteral, 0);
}

LcypherParser::OC_BooleanLiteralContext* LcypherParser::OC_LiteralContext::oC_BooleanLiteral() {
  return getRuleContext<LcypherParser::OC_BooleanLiteralContext>(0);
}

tree::TerminalNode* LcypherParser::OC_LiteralContext::NULL_() {
  return getToken(LcypherParser::NULL_, 0);
}

LcypherParser::OC_MapLiteralContext* LcypherParser::OC_LiteralContext::oC_MapLiteral() {
  return getRuleContext<LcypherParser::OC_MapLiteralContext>(0);
}

LcypherParser::OC_ListLiteralContext* LcypherParser::OC_LiteralContext::oC_ListLiteral() {
  return getRuleContext<LcypherParser::OC_ListLiteralContext>(0);
}


size_t LcypherParser::OC_LiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Literal;
}


std::any LcypherParser::OC_LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Literal(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_LiteralContext* LcypherParser::oC_Literal() {
  OC_LiteralContext *_localctx = _tracker.createInstance<OC_LiteralContext>(_ctx, getState());
  enterRule(_localctx, 132, LcypherParser::RuleOC_Literal);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1217);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::HexInteger:
      case LcypherParser::DecimalInteger:
      case LcypherParser::OctalInteger:
      case LcypherParser::ExponentDecimalReal:
      case LcypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(1211);
        oC_NumberLiteral();
        break;
      }

      case LcypherParser::StringLiteral: {
        enterOuterAlt(_localctx, 2);
        setState(1212);
        match(LcypherParser::StringLiteral);
        break;
      }

      case LcypherParser::TRUE_:
      case LcypherParser::FALSE_: {
        enterOuterAlt(_localctx, 3);
        setState(1213);
        oC_BooleanLiteral();
        break;
      }

      case LcypherParser::NULL_: {
        enterOuterAlt(_localctx, 4);
        setState(1214);
        match(LcypherParser::NULL_);
        break;
      }

      case LcypherParser::T__23: {
        enterOuterAlt(_localctx, 5);
        setState(1215);
        oC_MapLiteral();
        break;
      }

      case LcypherParser::T__7: {
        enterOuterAlt(_localctx, 6);
        setState(1216);
        oC_ListLiteral();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_BooleanLiteralContext ------------------------------------------------------------------

LcypherParser::OC_BooleanLiteralContext::OC_BooleanLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_BooleanLiteralContext::TRUE_() {
  return getToken(LcypherParser::TRUE_, 0);
}

tree::TerminalNode* LcypherParser::OC_BooleanLiteralContext::FALSE_() {
  return getToken(LcypherParser::FALSE_, 0);
}


size_t LcypherParser::OC_BooleanLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_BooleanLiteral;
}


std::any LcypherParser::OC_BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_BooleanLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_BooleanLiteralContext* LcypherParser::oC_BooleanLiteral() {
  OC_BooleanLiteralContext *_localctx = _tracker.createInstance<OC_BooleanLiteralContext>(_ctx, getState());
  enterRule(_localctx, 134, LcypherParser::RuleOC_BooleanLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1219);
    _la = _input->LA(1);
    if (!(_la == LcypherParser::TRUE_

    || _la == LcypherParser::FALSE_)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ListLiteralContext ------------------------------------------------------------------

LcypherParser::OC_ListLiteralContext::OC_ListLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ListLiteralContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ListLiteralContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_ListLiteralContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ListLiteralContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}


size_t LcypherParser::OC_ListLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ListLiteral;
}


std::any LcypherParser::OC_ListLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ListLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ListLiteralContext* LcypherParser::oC_ListLiteral() {
  OC_ListLiteralContext *_localctx = _tracker.createInstance<OC_ListLiteralContext>(_ctx, getState());
  enterRule(_localctx, 136, LcypherParser::RuleOC_ListLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1221);
    match(LcypherParser::T__7);
    setState(1223);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1222);
      match(LcypherParser::SP);
    }
    setState(1242);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 562950037332288) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 563083161436033) != 0)) {
      setState(1225);
      oC_Expression();
      setState(1227);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1226);
        match(LcypherParser::SP);
      }
      setState(1239);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == LcypherParser::T__1) {
        setState(1229);
        match(LcypherParser::T__1);
        setState(1231);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1230);
          match(LcypherParser::SP);
        }
        setState(1233);
        oC_Expression();
        setState(1235);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1234);
          match(LcypherParser::SP);
        }
        setState(1241);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1244);
    match(LcypherParser::T__8);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PartialComparisonExpressionContext ------------------------------------------------------------------

LcypherParser::OC_PartialComparisonExpressionContext::OC_PartialComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_AddOrSubtractExpressionContext* LcypherParser::OC_PartialComparisonExpressionContext::oC_AddOrSubtractExpression() {
  return getRuleContext<LcypherParser::OC_AddOrSubtractExpressionContext>(0);
}

tree::TerminalNode* LcypherParser::OC_PartialComparisonExpressionContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_PartialComparisonExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PartialComparisonExpression;
}


std::any LcypherParser::OC_PartialComparisonExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PartialComparisonExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PartialComparisonExpressionContext* LcypherParser::oC_PartialComparisonExpression() {
  OC_PartialComparisonExpressionContext *_localctx = _tracker.createInstance<OC_PartialComparisonExpressionContext>(_ctx, getState());
  enterRule(_localctx, 138, LcypherParser::RuleOC_PartialComparisonExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1276);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::T__2: {
        enterOuterAlt(_localctx, 1);
        setState(1246);
        match(LcypherParser::T__2);
        setState(1248);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1247);
          match(LcypherParser::SP);
        }
        setState(1250);
        oC_AddOrSubtractExpression();
        break;
      }

      case LcypherParser::T__17: {
        enterOuterAlt(_localctx, 2);
        setState(1251);
        match(LcypherParser::T__17);
        setState(1253);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1252);
          match(LcypherParser::SP);
        }
        setState(1255);
        oC_AddOrSubtractExpression();
        break;
      }

      case LcypherParser::T__18: {
        enterOuterAlt(_localctx, 3);
        setState(1256);
        match(LcypherParser::T__18);
        setState(1258);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1257);
          match(LcypherParser::SP);
        }
        setState(1260);
        oC_AddOrSubtractExpression();
        break;
      }

      case LcypherParser::T__19: {
        enterOuterAlt(_localctx, 4);
        setState(1261);
        match(LcypherParser::T__19);
        setState(1263);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1262);
          match(LcypherParser::SP);
        }
        setState(1265);
        oC_AddOrSubtractExpression();
        break;
      }

      case LcypherParser::T__20: {
        enterOuterAlt(_localctx, 5);
        setState(1266);
        match(LcypherParser::T__20);
        setState(1268);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1267);
          match(LcypherParser::SP);
        }
        setState(1270);
        oC_AddOrSubtractExpression();
        break;
      }

      case LcypherParser::T__21: {
        enterOuterAlt(_localctx, 6);
        setState(1271);
        match(LcypherParser::T__21);
        setState(1273);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1272);
          match(LcypherParser::SP);
        }
        setState(1275);
        oC_AddOrSubtractExpression();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ParenthesizedExpressionContext ------------------------------------------------------------------

LcypherParser::OC_ParenthesizedExpressionContext::OC_ParenthesizedExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ParenthesizedExpressionContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ParenthesizedExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ParenthesizedExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_ParenthesizedExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ParenthesizedExpression;
}


std::any LcypherParser::OC_ParenthesizedExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ParenthesizedExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ParenthesizedExpressionContext* LcypherParser::oC_ParenthesizedExpression() {
  OC_ParenthesizedExpressionContext *_localctx = _tracker.createInstance<OC_ParenthesizedExpressionContext>(_ctx, getState());
  enterRule(_localctx, 140, LcypherParser::RuleOC_ParenthesizedExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1278);
    match(LcypherParser::T__5);
    setState(1280);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1279);
      match(LcypherParser::SP);
    }
    setState(1282);
    oC_Expression();
    setState(1284);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1283);
      match(LcypherParser::SP);
    }
    setState(1286);
    match(LcypherParser::T__6);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipsPatternContext ------------------------------------------------------------------

LcypherParser::OC_RelationshipsPatternContext::OC_RelationshipsPatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_NodePatternContext* LcypherParser::OC_RelationshipsPatternContext::oC_NodePattern() {
  return getRuleContext<LcypherParser::OC_NodePatternContext>(0);
}

std::vector<LcypherParser::OC_PatternElementChainContext *> LcypherParser::OC_RelationshipsPatternContext::oC_PatternElementChain() {
  return getRuleContexts<LcypherParser::OC_PatternElementChainContext>();
}

LcypherParser::OC_PatternElementChainContext* LcypherParser::OC_RelationshipsPatternContext::oC_PatternElementChain(size_t i) {
  return getRuleContext<LcypherParser::OC_PatternElementChainContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_RelationshipsPatternContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_RelationshipsPatternContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_RelationshipsPatternContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RelationshipsPattern;
}


std::any LcypherParser::OC_RelationshipsPatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RelationshipsPattern(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RelationshipsPatternContext* LcypherParser::oC_RelationshipsPattern() {
  OC_RelationshipsPatternContext *_localctx = _tracker.createInstance<OC_RelationshipsPatternContext>(_ctx, getState());
  enterRule(_localctx, 142, LcypherParser::RuleOC_RelationshipsPattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1288);
    oC_NodePattern();
    setState(1293); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1290);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == LcypherParser::SP) {
                setState(1289);
                match(LcypherParser::SP);
              }
              setState(1292);
              oC_PatternElementChain();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1295); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_FilterExpressionContext ------------------------------------------------------------------

LcypherParser::OC_FilterExpressionContext::OC_FilterExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_IdInCollContext* LcypherParser::OC_FilterExpressionContext::oC_IdInColl() {
  return getRuleContext<LcypherParser::OC_IdInCollContext>(0);
}

LcypherParser::OC_WhereContext* LcypherParser::OC_FilterExpressionContext::oC_Where() {
  return getRuleContext<LcypherParser::OC_WhereContext>(0);
}

tree::TerminalNode* LcypherParser::OC_FilterExpressionContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_FilterExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_FilterExpression;
}


std::any LcypherParser::OC_FilterExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_FilterExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_FilterExpressionContext* LcypherParser::oC_FilterExpression() {
  OC_FilterExpressionContext *_localctx = _tracker.createInstance<OC_FilterExpressionContext>(_ctx, getState());
  enterRule(_localctx, 144, LcypherParser::RuleOC_FilterExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1297);
    oC_IdInColl();
    setState(1302);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx)) {
    case 1: {
      setState(1299);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1298);
        match(LcypherParser::SP);
      }
      setState(1301);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_IdInCollContext ------------------------------------------------------------------

LcypherParser::OC_IdInCollContext::OC_IdInCollContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_VariableContext* LcypherParser::OC_IdInCollContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_IdInCollContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_IdInCollContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_IdInCollContext::IN() {
  return getToken(LcypherParser::IN, 0);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_IdInCollContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}


size_t LcypherParser::OC_IdInCollContext::getRuleIndex() const {
  return LcypherParser::RuleOC_IdInColl;
}


std::any LcypherParser::OC_IdInCollContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_IdInColl(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_IdInCollContext* LcypherParser::oC_IdInColl() {
  OC_IdInCollContext *_localctx = _tracker.createInstance<OC_IdInCollContext>(_ctx, getState());
  enterRule(_localctx, 146, LcypherParser::RuleOC_IdInColl);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1304);
    oC_Variable();
    setState(1305);
    match(LcypherParser::SP);
    setState(1306);
    match(LcypherParser::IN);
    setState(1307);
    match(LcypherParser::SP);
    setState(1308);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_FunctionInvocationContext ------------------------------------------------------------------

LcypherParser::OC_FunctionInvocationContext::OC_FunctionInvocationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_FunctionNameContext* LcypherParser::OC_FunctionInvocationContext::oC_FunctionName() {
  return getRuleContext<LcypherParser::OC_FunctionNameContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_FunctionInvocationContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_FunctionInvocationContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_FunctionInvocationContext::DISTINCT() {
  return getToken(LcypherParser::DISTINCT, 0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_FunctionInvocationContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_FunctionInvocationContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}


size_t LcypherParser::OC_FunctionInvocationContext::getRuleIndex() const {
  return LcypherParser::RuleOC_FunctionInvocation;
}


std::any LcypherParser::OC_FunctionInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_FunctionInvocation(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_FunctionInvocationContext* LcypherParser::oC_FunctionInvocation() {
  OC_FunctionInvocationContext *_localctx = _tracker.createInstance<OC_FunctionInvocationContext>(_ctx, getState());
  enterRule(_localctx, 148, LcypherParser::RuleOC_FunctionInvocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1310);
    oC_FunctionName();
    setState(1312);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1311);
      match(LcypherParser::SP);
    }
    setState(1314);
    match(LcypherParser::T__5);
    setState(1316);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1315);
      match(LcypherParser::SP);
    }
    setState(1322);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::DISTINCT) {
      setState(1318);
      match(LcypherParser::DISTINCT);
      setState(1320);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1319);
        match(LcypherParser::SP);
      }
    }
    setState(1341);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 562950037332288) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 563083161436033) != 0)) {
      setState(1324);
      oC_Expression();
      setState(1326);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1325);
        match(LcypherParser::SP);
      }
      setState(1338);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == LcypherParser::T__1) {
        setState(1328);
        match(LcypherParser::T__1);
        setState(1330);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1329);
          match(LcypherParser::SP);
        }
        setState(1332);
        oC_Expression();
        setState(1334);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1333);
          match(LcypherParser::SP);
        }
        setState(1340);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1343);
    match(LcypherParser::T__6);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_FunctionNameContext ------------------------------------------------------------------

LcypherParser::OC_FunctionNameContext::OC_FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_NamespaceContext* LcypherParser::OC_FunctionNameContext::oC_Namespace() {
  return getRuleContext<LcypherParser::OC_NamespaceContext>(0);
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_FunctionNameContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* LcypherParser::OC_FunctionNameContext::EXISTS() {
  return getToken(LcypherParser::EXISTS, 0);
}


size_t LcypherParser::OC_FunctionNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_FunctionName;
}


std::any LcypherParser::OC_FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_FunctionName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_FunctionNameContext* LcypherParser::oC_FunctionName() {
  OC_FunctionNameContext *_localctx = _tracker.createInstance<OC_FunctionNameContext>(_ctx, getState());
  enterRule(_localctx, 150, LcypherParser::RuleOC_FunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1349);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::HexLetter:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(1345);
        oC_Namespace();
        setState(1346);
        oC_SymbolicName();
        break;
      }

      case LcypherParser::EXISTS: {
        enterOuterAlt(_localctx, 2);
        setState(1348);
        match(LcypherParser::EXISTS);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ExplicitProcedureInvocationContext ------------------------------------------------------------------

LcypherParser::OC_ExplicitProcedureInvocationContext::OC_ExplicitProcedureInvocationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ProcedureNameContext* LcypherParser::OC_ExplicitProcedureInvocationContext::oC_ProcedureName() {
  return getRuleContext<LcypherParser::OC_ProcedureNameContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ExplicitProcedureInvocationContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ExplicitProcedureInvocationContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_ExplicitProcedureInvocationContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ExplicitProcedureInvocationContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}


size_t LcypherParser::OC_ExplicitProcedureInvocationContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ExplicitProcedureInvocation;
}


std::any LcypherParser::OC_ExplicitProcedureInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ExplicitProcedureInvocation(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ExplicitProcedureInvocationContext* LcypherParser::oC_ExplicitProcedureInvocation() {
  OC_ExplicitProcedureInvocationContext *_localctx = _tracker.createInstance<OC_ExplicitProcedureInvocationContext>(_ctx, getState());
  enterRule(_localctx, 152, LcypherParser::RuleOC_ExplicitProcedureInvocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1351);
    oC_ProcedureName();
    setState(1353);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1352);
      match(LcypherParser::SP);
    }
    setState(1355);
    match(LcypherParser::T__5);
    setState(1357);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1356);
      match(LcypherParser::SP);
    }
    setState(1376);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 562950037332288) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 563083161436033) != 0)) {
      setState(1359);
      oC_Expression();
      setState(1361);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1360);
        match(LcypherParser::SP);
      }
      setState(1373);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == LcypherParser::T__1) {
        setState(1363);
        match(LcypherParser::T__1);
        setState(1365);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1364);
          match(LcypherParser::SP);
        }
        setState(1367);
        oC_Expression();
        setState(1369);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1368);
          match(LcypherParser::SP);
        }
        setState(1375);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1378);
    match(LcypherParser::T__6);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ImplicitProcedureInvocationContext ------------------------------------------------------------------

LcypherParser::OC_ImplicitProcedureInvocationContext::OC_ImplicitProcedureInvocationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_ProcedureNameContext* LcypherParser::OC_ImplicitProcedureInvocationContext::oC_ProcedureName() {
  return getRuleContext<LcypherParser::OC_ProcedureNameContext>(0);
}


size_t LcypherParser::OC_ImplicitProcedureInvocationContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ImplicitProcedureInvocation;
}


std::any LcypherParser::OC_ImplicitProcedureInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ImplicitProcedureInvocation(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ImplicitProcedureInvocationContext* LcypherParser::oC_ImplicitProcedureInvocation() {
  OC_ImplicitProcedureInvocationContext *_localctx = _tracker.createInstance<OC_ImplicitProcedureInvocationContext>(_ctx, getState());
  enterRule(_localctx, 154, LcypherParser::RuleOC_ImplicitProcedureInvocation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1380);
    oC_ProcedureName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ProcedureResultFieldContext ------------------------------------------------------------------

LcypherParser::OC_ProcedureResultFieldContext::OC_ProcedureResultFieldContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_ProcedureResultFieldContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}


size_t LcypherParser::OC_ProcedureResultFieldContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ProcedureResultField;
}


std::any LcypherParser::OC_ProcedureResultFieldContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ProcedureResultField(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ProcedureResultFieldContext* LcypherParser::oC_ProcedureResultField() {
  OC_ProcedureResultFieldContext *_localctx = _tracker.createInstance<OC_ProcedureResultFieldContext>(_ctx, getState());
  enterRule(_localctx, 156, LcypherParser::RuleOC_ProcedureResultField);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1382);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ProcedureNameContext ------------------------------------------------------------------

LcypherParser::OC_ProcedureNameContext::OC_ProcedureNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_NamespaceContext* LcypherParser::OC_ProcedureNameContext::oC_Namespace() {
  return getRuleContext<LcypherParser::OC_NamespaceContext>(0);
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_ProcedureNameContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}


size_t LcypherParser::OC_ProcedureNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ProcedureName;
}


std::any LcypherParser::OC_ProcedureNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ProcedureName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ProcedureNameContext* LcypherParser::oC_ProcedureName() {
  OC_ProcedureNameContext *_localctx = _tracker.createInstance<OC_ProcedureNameContext>(_ctx, getState());
  enterRule(_localctx, 158, LcypherParser::RuleOC_ProcedureName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1384);
    oC_Namespace();
    setState(1385);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NamespaceContext ------------------------------------------------------------------

LcypherParser::OC_NamespaceContext::OC_NamespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<LcypherParser::OC_SymbolicNameContext *> LcypherParser::OC_NamespaceContext::oC_SymbolicName() {
  return getRuleContexts<LcypherParser::OC_SymbolicNameContext>();
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_NamespaceContext::oC_SymbolicName(size_t i) {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(i);
}


size_t LcypherParser::OC_NamespaceContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Namespace;
}


std::any LcypherParser::OC_NamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Namespace(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NamespaceContext* LcypherParser::oC_Namespace() {
  OC_NamespaceContext *_localctx = _tracker.createInstance<OC_NamespaceContext>(_ctx, getState());
  enterRule(_localctx, 160, LcypherParser::RuleOC_Namespace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1392);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 248, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1387);
        oC_SymbolicName();
        setState(1388);
        match(LcypherParser::T__22); 
      }
      setState(1394);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 248, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ListComprehensionContext ------------------------------------------------------------------

LcypherParser::OC_ListComprehensionContext::OC_ListComprehensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_FilterExpressionContext* LcypherParser::OC_ListComprehensionContext::oC_FilterExpression() {
  return getRuleContext<LcypherParser::OC_FilterExpressionContext>(0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_ListComprehensionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_ListComprehensionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_ListComprehensionContext::oC_Expression() {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(0);
}


size_t LcypherParser::OC_ListComprehensionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ListComprehension;
}


std::any LcypherParser::OC_ListComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ListComprehension(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ListComprehensionContext* LcypherParser::oC_ListComprehension() {
  OC_ListComprehensionContext *_localctx = _tracker.createInstance<OC_ListComprehensionContext>(_ctx, getState());
  enterRule(_localctx, 162, LcypherParser::RuleOC_ListComprehension);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1395);
    match(LcypherParser::T__7);
    setState(1397);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1396);
      match(LcypherParser::SP);
    }
    setState(1399);
    oC_FilterExpression();
    setState(1408);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      setState(1401);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1400);
        match(LcypherParser::SP);
      }
      setState(1403);
      match(LcypherParser::T__10);
      setState(1405);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1404);
        match(LcypherParser::SP);
      }
      setState(1407);
      oC_Expression();
      break;
    }

    default:
      break;
    }
    setState(1411);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1410);
      match(LcypherParser::SP);
    }
    setState(1413);
    match(LcypherParser::T__8);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternComprehensionContext ------------------------------------------------------------------

LcypherParser::OC_PatternComprehensionContext::OC_PatternComprehensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_RelationshipsPatternContext* LcypherParser::OC_PatternComprehensionContext::oC_RelationshipsPattern() {
  return getRuleContext<LcypherParser::OC_RelationshipsPatternContext>(0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_PatternComprehensionContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_PatternComprehensionContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PatternComprehensionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PatternComprehensionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

LcypherParser::OC_VariableContext* LcypherParser::OC_PatternComprehensionContext::oC_Variable() {
  return getRuleContext<LcypherParser::OC_VariableContext>(0);
}

tree::TerminalNode* LcypherParser::OC_PatternComprehensionContext::WHERE() {
  return getToken(LcypherParser::WHERE, 0);
}


size_t LcypherParser::OC_PatternComprehensionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PatternComprehension;
}


std::any LcypherParser::OC_PatternComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PatternComprehension(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PatternComprehensionContext* LcypherParser::oC_PatternComprehension() {
  OC_PatternComprehensionContext *_localctx = _tracker.createInstance<OC_PatternComprehensionContext>(_ctx, getState());
  enterRule(_localctx, 164, LcypherParser::RuleOC_PatternComprehension);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1415);
    match(LcypherParser::T__7);
    setState(1417);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1416);
      match(LcypherParser::SP);
    }
    setState(1427);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 89) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 89)) & 2199493148687) != 0)) {
      setState(1419);
      oC_Variable();
      setState(1421);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1420);
        match(LcypherParser::SP);
      }
      setState(1423);
      match(LcypherParser::T__2);
      setState(1425);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1424);
        match(LcypherParser::SP);
      }
    }
    setState(1429);
    oC_RelationshipsPattern();
    setState(1431);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1430);
      match(LcypherParser::SP);
    }
    setState(1441);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::WHERE) {
      setState(1433);
      match(LcypherParser::WHERE);
      setState(1435);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1434);
        match(LcypherParser::SP);
      }
      setState(1437);
      oC_Expression();
      setState(1439);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1438);
        match(LcypherParser::SP);
      }
    }
    setState(1443);
    match(LcypherParser::T__10);
    setState(1445);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1444);
      match(LcypherParser::SP);
    }
    setState(1447);
    oC_Expression();
    setState(1449);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1448);
      match(LcypherParser::SP);
    }
    setState(1451);
    match(LcypherParser::T__8);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyLookupContext ------------------------------------------------------------------

LcypherParser::OC_PropertyLookupContext::OC_PropertyLookupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_PropertyKeyNameContext* LcypherParser::OC_PropertyLookupContext::oC_PropertyKeyName() {
  return getRuleContext<LcypherParser::OC_PropertyKeyNameContext>(0);
}

tree::TerminalNode* LcypherParser::OC_PropertyLookupContext::SP() {
  return getToken(LcypherParser::SP, 0);
}


size_t LcypherParser::OC_PropertyLookupContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PropertyLookup;
}


std::any LcypherParser::OC_PropertyLookupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PropertyLookup(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PropertyLookupContext* LcypherParser::oC_PropertyLookup() {
  OC_PropertyLookupContext *_localctx = _tracker.createInstance<OC_PropertyLookupContext>(_ctx, getState());
  enterRule(_localctx, 166, LcypherParser::RuleOC_PropertyLookup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1453);
    match(LcypherParser::T__22);
    setState(1455);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1454);
      match(LcypherParser::SP);
    }

    setState(1457);
    oC_PropertyKeyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CaseExpressionContext ------------------------------------------------------------------

LcypherParser::OC_CaseExpressionContext::OC_CaseExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_CaseExpressionContext::END() {
  return getToken(LcypherParser::END, 0);
}

tree::TerminalNode* LcypherParser::OC_CaseExpressionContext::ELSE() {
  return getToken(LcypherParser::ELSE, 0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_CaseExpressionContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_CaseExpressionContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_CaseExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_CaseExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

tree::TerminalNode* LcypherParser::OC_CaseExpressionContext::CASE() {
  return getToken(LcypherParser::CASE, 0);
}

std::vector<LcypherParser::OC_CaseAlternativesContext *> LcypherParser::OC_CaseExpressionContext::oC_CaseAlternatives() {
  return getRuleContexts<LcypherParser::OC_CaseAlternativesContext>();
}

LcypherParser::OC_CaseAlternativesContext* LcypherParser::OC_CaseExpressionContext::oC_CaseAlternatives(size_t i) {
  return getRuleContext<LcypherParser::OC_CaseAlternativesContext>(i);
}


size_t LcypherParser::OC_CaseExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_CaseExpression;
}


std::any LcypherParser::OC_CaseExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_CaseExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_CaseExpressionContext* LcypherParser::oC_CaseExpression() {
  OC_CaseExpressionContext *_localctx = _tracker.createInstance<OC_CaseExpressionContext>(_ctx, getState());
  enterRule(_localctx, 168, LcypherParser::RuleOC_CaseExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1481);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
    case 1: {
      setState(1459);
      match(LcypherParser::CASE);
      setState(1464); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1461);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == LcypherParser::SP) {
                  setState(1460);
                  match(LcypherParser::SP);
                }
                setState(1463);
                oC_CaseAlternatives();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1466); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 266, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 2: {
      setState(1468);
      match(LcypherParser::CASE);
      setState(1470);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1469);
        match(LcypherParser::SP);
      }
      setState(1472);
      oC_Expression();
      setState(1477); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1474);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == LcypherParser::SP) {
                  setState(1473);
                  match(LcypherParser::SP);
                }
                setState(1476);
                oC_CaseAlternatives();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1479); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 269, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    default:
      break;
    }
    setState(1491);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 273, _ctx)) {
    case 1: {
      setState(1484);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1483);
        match(LcypherParser::SP);
      }
      setState(1486);
      match(LcypherParser::ELSE);
      setState(1488);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1487);
        match(LcypherParser::SP);
      }
      setState(1490);
      oC_Expression();
      break;
    }

    default:
      break;
    }
    setState(1494);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1493);
      match(LcypherParser::SP);
    }
    setState(1496);
    match(LcypherParser::END);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CaseAlternativesContext ------------------------------------------------------------------

LcypherParser::OC_CaseAlternativesContext::OC_CaseAlternativesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_CaseAlternativesContext::WHEN() {
  return getToken(LcypherParser::WHEN, 0);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_CaseAlternativesContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_CaseAlternativesContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}

tree::TerminalNode* LcypherParser::OC_CaseAlternativesContext::THEN() {
  return getToken(LcypherParser::THEN, 0);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_CaseAlternativesContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_CaseAlternativesContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_CaseAlternativesContext::getRuleIndex() const {
  return LcypherParser::RuleOC_CaseAlternatives;
}


std::any LcypherParser::OC_CaseAlternativesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_CaseAlternatives(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_CaseAlternativesContext* LcypherParser::oC_CaseAlternatives() {
  OC_CaseAlternativesContext *_localctx = _tracker.createInstance<OC_CaseAlternativesContext>(_ctx, getState());
  enterRule(_localctx, 170, LcypherParser::RuleOC_CaseAlternatives);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1498);
    match(LcypherParser::WHEN);
    setState(1500);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1499);
      match(LcypherParser::SP);
    }
    setState(1502);
    oC_Expression();
    setState(1504);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1503);
      match(LcypherParser::SP);
    }
    setState(1506);
    match(LcypherParser::THEN);
    setState(1508);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1507);
      match(LcypherParser::SP);
    }
    setState(1510);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_VariableContext ------------------------------------------------------------------

LcypherParser::OC_VariableContext::OC_VariableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_VariableContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}


size_t LcypherParser::OC_VariableContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Variable;
}


std::any LcypherParser::OC_VariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Variable(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_VariableContext* LcypherParser::oC_Variable() {
  OC_VariableContext *_localctx = _tracker.createInstance<OC_VariableContext>(_ctx, getState());
  enterRule(_localctx, 172, LcypherParser::RuleOC_Variable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1512);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NumberLiteralContext ------------------------------------------------------------------

LcypherParser::OC_NumberLiteralContext::OC_NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_DoubleLiteralContext* LcypherParser::OC_NumberLiteralContext::oC_DoubleLiteral() {
  return getRuleContext<LcypherParser::OC_DoubleLiteralContext>(0);
}

LcypherParser::OC_IntegerLiteralContext* LcypherParser::OC_NumberLiteralContext::oC_IntegerLiteral() {
  return getRuleContext<LcypherParser::OC_IntegerLiteralContext>(0);
}


size_t LcypherParser::OC_NumberLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_NumberLiteral;
}


std::any LcypherParser::OC_NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_NumberLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_NumberLiteralContext* LcypherParser::oC_NumberLiteral() {
  OC_NumberLiteralContext *_localctx = _tracker.createInstance<OC_NumberLiteralContext>(_ctx, getState());
  enterRule(_localctx, 174, LcypherParser::RuleOC_NumberLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1516);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::ExponentDecimalReal:
      case LcypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(1514);
        oC_DoubleLiteral();
        break;
      }

      case LcypherParser::HexInteger:
      case LcypherParser::DecimalInteger:
      case LcypherParser::OctalInteger: {
        enterOuterAlt(_localctx, 2);
        setState(1515);
        oC_IntegerLiteral();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MapLiteralContext ------------------------------------------------------------------

LcypherParser::OC_MapLiteralContext::OC_MapLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> LcypherParser::OC_MapLiteralContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_MapLiteralContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}

std::vector<LcypherParser::OC_PropertyKeyNameContext *> LcypherParser::OC_MapLiteralContext::oC_PropertyKeyName() {
  return getRuleContexts<LcypherParser::OC_PropertyKeyNameContext>();
}

LcypherParser::OC_PropertyKeyNameContext* LcypherParser::OC_MapLiteralContext::oC_PropertyKeyName(size_t i) {
  return getRuleContext<LcypherParser::OC_PropertyKeyNameContext>(i);
}

std::vector<LcypherParser::OC_ExpressionContext *> LcypherParser::OC_MapLiteralContext::oC_Expression() {
  return getRuleContexts<LcypherParser::OC_ExpressionContext>();
}

LcypherParser::OC_ExpressionContext* LcypherParser::OC_MapLiteralContext::oC_Expression(size_t i) {
  return getRuleContext<LcypherParser::OC_ExpressionContext>(i);
}


size_t LcypherParser::OC_MapLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_MapLiteral;
}


std::any LcypherParser::OC_MapLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_MapLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_MapLiteralContext* LcypherParser::oC_MapLiteral() {
  OC_MapLiteralContext *_localctx = _tracker.createInstance<OC_MapLiteralContext>(_ctx, getState());
  enterRule(_localctx, 176, LcypherParser::RuleOC_MapLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1518);
    match(LcypherParser::T__23);
    setState(1520);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == LcypherParser::SP) {
      setState(1519);
      match(LcypherParser::SP);
    }
    setState(1555);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 297237300058759167) != 0) || ((((_la - 115) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 115)) & 40959) != 0)) {
      setState(1522);
      oC_PropertyKeyName();
      setState(1524);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1523);
        match(LcypherParser::SP);
      }
      setState(1526);
      match(LcypherParser::T__9);
      setState(1528);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1527);
        match(LcypherParser::SP);
      }
      setState(1530);
      oC_Expression();
      setState(1532);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == LcypherParser::SP) {
        setState(1531);
        match(LcypherParser::SP);
      }
      setState(1552);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == LcypherParser::T__1) {
        setState(1534);
        match(LcypherParser::T__1);
        setState(1536);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1535);
          match(LcypherParser::SP);
        }
        setState(1538);
        oC_PropertyKeyName();
        setState(1540);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1539);
          match(LcypherParser::SP);
        }
        setState(1542);
        match(LcypherParser::T__9);
        setState(1544);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1543);
          match(LcypherParser::SP);
        }
        setState(1546);
        oC_Expression();
        setState(1548);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == LcypherParser::SP) {
          setState(1547);
          match(LcypherParser::SP);
        }
        setState(1554);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1557);
    match(LcypherParser::T__24);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ParameterContext ------------------------------------------------------------------

LcypherParser::OC_ParameterContext::OC_ParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_ParameterContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* LcypherParser::OC_ParameterContext::DecimalInteger() {
  return getToken(LcypherParser::DecimalInteger, 0);
}


size_t LcypherParser::OC_ParameterContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Parameter;
}


std::any LcypherParser::OC_ParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Parameter(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ParameterContext* LcypherParser::oC_Parameter() {
  OC_ParameterContext *_localctx = _tracker.createInstance<OC_ParameterContext>(_ctx, getState());
  enterRule(_localctx, 178, LcypherParser::RuleOC_Parameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1559);
    match(LcypherParser::T__25);
    setState(1562);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::HexLetter:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        setState(1560);
        oC_SymbolicName();
        break;
      }

      case LcypherParser::DecimalInteger: {
        setState(1561);
        match(LcypherParser::DecimalInteger);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyExpressionContext ------------------------------------------------------------------

LcypherParser::OC_PropertyExpressionContext::OC_PropertyExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_AtomContext* LcypherParser::OC_PropertyExpressionContext::oC_Atom() {
  return getRuleContext<LcypherParser::OC_AtomContext>(0);
}

std::vector<LcypherParser::OC_PropertyLookupContext *> LcypherParser::OC_PropertyExpressionContext::oC_PropertyLookup() {
  return getRuleContexts<LcypherParser::OC_PropertyLookupContext>();
}

LcypherParser::OC_PropertyLookupContext* LcypherParser::OC_PropertyExpressionContext::oC_PropertyLookup(size_t i) {
  return getRuleContext<LcypherParser::OC_PropertyLookupContext>(i);
}

std::vector<tree::TerminalNode *> LcypherParser::OC_PropertyExpressionContext::SP() {
  return getTokens(LcypherParser::SP);
}

tree::TerminalNode* LcypherParser::OC_PropertyExpressionContext::SP(size_t i) {
  return getToken(LcypherParser::SP, i);
}


size_t LcypherParser::OC_PropertyExpressionContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PropertyExpression;
}


std::any LcypherParser::OC_PropertyExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PropertyExpression(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PropertyExpressionContext* LcypherParser::oC_PropertyExpression() {
  OC_PropertyExpressionContext *_localctx = _tracker.createInstance<OC_PropertyExpressionContext>(_ctx, getState());
  enterRule(_localctx, 180, LcypherParser::RuleOC_PropertyExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1564);
    oC_Atom();
    setState(1569); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1566);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == LcypherParser::SP) {
                setState(1565);
                match(LcypherParser::SP);
              }
              setState(1568);
              oC_PropertyLookup();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1571); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 291, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyKeyNameContext ------------------------------------------------------------------

LcypherParser::OC_PropertyKeyNameContext::OC_PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SchemaNameContext* LcypherParser::OC_PropertyKeyNameContext::oC_SchemaName() {
  return getRuleContext<LcypherParser::OC_SchemaNameContext>(0);
}


size_t LcypherParser::OC_PropertyKeyNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_PropertyKeyName;
}


std::any LcypherParser::OC_PropertyKeyNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_PropertyKeyName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_PropertyKeyNameContext* LcypherParser::oC_PropertyKeyName() {
  OC_PropertyKeyNameContext *_localctx = _tracker.createInstance<OC_PropertyKeyNameContext>(_ctx, getState());
  enterRule(_localctx, 182, LcypherParser::RuleOC_PropertyKeyName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1573);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_IntegerLiteralContext ------------------------------------------------------------------

LcypherParser::OC_IntegerLiteralContext::OC_IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_IntegerLiteralContext::HexInteger() {
  return getToken(LcypherParser::HexInteger, 0);
}

tree::TerminalNode* LcypherParser::OC_IntegerLiteralContext::OctalInteger() {
  return getToken(LcypherParser::OctalInteger, 0);
}

tree::TerminalNode* LcypherParser::OC_IntegerLiteralContext::DecimalInteger() {
  return getToken(LcypherParser::DecimalInteger, 0);
}


size_t LcypherParser::OC_IntegerLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_IntegerLiteral;
}


std::any LcypherParser::OC_IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_IntegerLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_IntegerLiteralContext* LcypherParser::oC_IntegerLiteral() {
  OC_IntegerLiteralContext *_localctx = _tracker.createInstance<OC_IntegerLiteralContext>(_ctx, getState());
  enterRule(_localctx, 184, LcypherParser::RuleOC_IntegerLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1575);
    _la = _input->LA(1);
    if (!(((((_la - 103) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 103)) & 7) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_DoubleLiteralContext ------------------------------------------------------------------

LcypherParser::OC_DoubleLiteralContext::OC_DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_DoubleLiteralContext::ExponentDecimalReal() {
  return getToken(LcypherParser::ExponentDecimalReal, 0);
}

tree::TerminalNode* LcypherParser::OC_DoubleLiteralContext::RegularDecimalReal() {
  return getToken(LcypherParser::RegularDecimalReal, 0);
}


size_t LcypherParser::OC_DoubleLiteralContext::getRuleIndex() const {
  return LcypherParser::RuleOC_DoubleLiteral;
}


std::any LcypherParser::OC_DoubleLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_DoubleLiteral(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_DoubleLiteralContext* LcypherParser::oC_DoubleLiteral() {
  OC_DoubleLiteralContext *_localctx = _tracker.createInstance<OC_DoubleLiteralContext>(_ctx, getState());
  enterRule(_localctx, 186, LcypherParser::RuleOC_DoubleLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1577);
    _la = _input->LA(1);
    if (!(_la == LcypherParser::ExponentDecimalReal

    || _la == LcypherParser::RegularDecimalReal)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SchemaNameContext ------------------------------------------------------------------

LcypherParser::OC_SchemaNameContext::OC_SchemaNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::OC_SchemaNameContext::oC_SymbolicName() {
  return getRuleContext<LcypherParser::OC_SymbolicNameContext>(0);
}

LcypherParser::OC_ReservedWordContext* LcypherParser::OC_SchemaNameContext::oC_ReservedWord() {
  return getRuleContext<LcypherParser::OC_ReservedWordContext>(0);
}


size_t LcypherParser::OC_SchemaNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SchemaName;
}


std::any LcypherParser::OC_SchemaNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SchemaName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SchemaNameContext* LcypherParser::oC_SchemaName() {
  OC_SchemaNameContext *_localctx = _tracker.createInstance<OC_SchemaNameContext>(_ctx, getState());
  enterRule(_localctx, 188, LcypherParser::RuleOC_SchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1581);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case LcypherParser::COUNT:
      case LcypherParser::ANY:
      case LcypherParser::NONE:
      case LcypherParser::SINGLE:
      case LcypherParser::HexLetter:
      case LcypherParser::FILTER:
      case LcypherParser::EXTRACT:
      case LcypherParser::UnescapedSymbolicName:
      case LcypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(1579);
        oC_SymbolicName();
        break;
      }

      case LcypherParser::UNION:
      case LcypherParser::ALL:
      case LcypherParser::OPTIONAL_:
      case LcypherParser::MATCH:
      case LcypherParser::UNWIND:
      case LcypherParser::AS:
      case LcypherParser::MERGE:
      case LcypherParser::ON:
      case LcypherParser::CREATE:
      case LcypherParser::SET:
      case LcypherParser::DETACH:
      case LcypherParser::DELETE_:
      case LcypherParser::REMOVE:
      case LcypherParser::WITH:
      case LcypherParser::DISTINCT:
      case LcypherParser::RETURN:
      case LcypherParser::ORDER:
      case LcypherParser::BY:
      case LcypherParser::L_SKIP:
      case LcypherParser::LIMIT:
      case LcypherParser::ASCENDING:
      case LcypherParser::ASC:
      case LcypherParser::DESCENDING:
      case LcypherParser::DESC:
      case LcypherParser::WHERE:
      case LcypherParser::OR:
      case LcypherParser::XOR:
      case LcypherParser::AND:
      case LcypherParser::NOT:
      case LcypherParser::IN:
      case LcypherParser::STARTS:
      case LcypherParser::ENDS:
      case LcypherParser::CONTAINS:
      case LcypherParser::IS:
      case LcypherParser::NULL_:
      case LcypherParser::TRUE_:
      case LcypherParser::FALSE_:
      case LcypherParser::EXISTS:
      case LcypherParser::CASE:
      case LcypherParser::ELSE:
      case LcypherParser::END:
      case LcypherParser::WHEN:
      case LcypherParser::THEN:
      case LcypherParser::CONSTRAINT:
      case LcypherParser::DO:
      case LcypherParser::FOR:
      case LcypherParser::REQUIRE:
      case LcypherParser::UNIQUE:
      case LcypherParser::MANDATORY:
      case LcypherParser::SCALAR:
      case LcypherParser::OF:
      case LcypherParser::ADD:
      case LcypherParser::DROP: {
        enterOuterAlt(_localctx, 2);
        setState(1580);
        oC_ReservedWord();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SymbolicNameContext ------------------------------------------------------------------

LcypherParser::OC_SymbolicNameContext::OC_SymbolicNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::UnescapedSymbolicName() {
  return getToken(LcypherParser::UnescapedSymbolicName, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::EscapedSymbolicName() {
  return getToken(LcypherParser::EscapedSymbolicName, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::HexLetter() {
  return getToken(LcypherParser::HexLetter, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::COUNT() {
  return getToken(LcypherParser::COUNT, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::FILTER() {
  return getToken(LcypherParser::FILTER, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::EXTRACT() {
  return getToken(LcypherParser::EXTRACT, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::ANY() {
  return getToken(LcypherParser::ANY, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::NONE() {
  return getToken(LcypherParser::NONE, 0);
}

tree::TerminalNode* LcypherParser::OC_SymbolicNameContext::SINGLE() {
  return getToken(LcypherParser::SINGLE, 0);
}


size_t LcypherParser::OC_SymbolicNameContext::getRuleIndex() const {
  return LcypherParser::RuleOC_SymbolicName;
}


std::any LcypherParser::OC_SymbolicNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_SymbolicName(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_SymbolicNameContext* LcypherParser::oC_SymbolicName() {
  OC_SymbolicNameContext *_localctx = _tracker.createInstance<OC_SymbolicNameContext>(_ctx, getState());
  enterRule(_localctx, 190, LcypherParser::RuleOC_SymbolicName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1583);
    _la = _input->LA(1);
    if (!(((((_la - 89) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 89)) & 2199493148687) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReservedWordContext ------------------------------------------------------------------

LcypherParser::OC_ReservedWordContext::OC_ReservedWordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ALL() {
  return getToken(LcypherParser::ALL, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ASC() {
  return getToken(LcypherParser::ASC, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ASCENDING() {
  return getToken(LcypherParser::ASCENDING, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::BY() {
  return getToken(LcypherParser::BY, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::CREATE() {
  return getToken(LcypherParser::CREATE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DELETE_() {
  return getToken(LcypherParser::DELETE_, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DESC() {
  return getToken(LcypherParser::DESC, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DESCENDING() {
  return getToken(LcypherParser::DESCENDING, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DETACH() {
  return getToken(LcypherParser::DETACH, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::EXISTS() {
  return getToken(LcypherParser::EXISTS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::LIMIT() {
  return getToken(LcypherParser::LIMIT, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::MATCH() {
  return getToken(LcypherParser::MATCH, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::MERGE() {
  return getToken(LcypherParser::MERGE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ON() {
  return getToken(LcypherParser::ON, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::OPTIONAL_() {
  return getToken(LcypherParser::OPTIONAL_, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ORDER() {
  return getToken(LcypherParser::ORDER, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::REMOVE() {
  return getToken(LcypherParser::REMOVE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::RETURN() {
  return getToken(LcypherParser::RETURN, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::SET() {
  return getToken(LcypherParser::SET, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::L_SKIP() {
  return getToken(LcypherParser::L_SKIP, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::WHERE() {
  return getToken(LcypherParser::WHERE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::WITH() {
  return getToken(LcypherParser::WITH, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::UNION() {
  return getToken(LcypherParser::UNION, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::UNWIND() {
  return getToken(LcypherParser::UNWIND, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::AND() {
  return getToken(LcypherParser::AND, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::AS() {
  return getToken(LcypherParser::AS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::CONTAINS() {
  return getToken(LcypherParser::CONTAINS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DISTINCT() {
  return getToken(LcypherParser::DISTINCT, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ENDS() {
  return getToken(LcypherParser::ENDS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::IN() {
  return getToken(LcypherParser::IN, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::IS() {
  return getToken(LcypherParser::IS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::NOT() {
  return getToken(LcypherParser::NOT, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::OR() {
  return getToken(LcypherParser::OR, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::STARTS() {
  return getToken(LcypherParser::STARTS, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::XOR() {
  return getToken(LcypherParser::XOR, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::FALSE_() {
  return getToken(LcypherParser::FALSE_, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::TRUE_() {
  return getToken(LcypherParser::TRUE_, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::NULL_() {
  return getToken(LcypherParser::NULL_, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::CONSTRAINT() {
  return getToken(LcypherParser::CONSTRAINT, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DO() {
  return getToken(LcypherParser::DO, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::FOR() {
  return getToken(LcypherParser::FOR, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::REQUIRE() {
  return getToken(LcypherParser::REQUIRE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::UNIQUE() {
  return getToken(LcypherParser::UNIQUE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::CASE() {
  return getToken(LcypherParser::CASE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::WHEN() {
  return getToken(LcypherParser::WHEN, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::THEN() {
  return getToken(LcypherParser::THEN, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ELSE() {
  return getToken(LcypherParser::ELSE, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::END() {
  return getToken(LcypherParser::END, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::MANDATORY() {
  return getToken(LcypherParser::MANDATORY, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::SCALAR() {
  return getToken(LcypherParser::SCALAR, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::OF() {
  return getToken(LcypherParser::OF, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::ADD() {
  return getToken(LcypherParser::ADD, 0);
}

tree::TerminalNode* LcypherParser::OC_ReservedWordContext::DROP() {
  return getToken(LcypherParser::DROP, 0);
}


size_t LcypherParser::OC_ReservedWordContext::getRuleIndex() const {
  return LcypherParser::RuleOC_ReservedWord;
}


std::any LcypherParser::OC_ReservedWordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_ReservedWord(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_ReservedWordContext* LcypherParser::oC_ReservedWord() {
  OC_ReservedWordContext *_localctx = _tracker.createInstance<OC_ReservedWordContext>(_ctx, getState());
  enterRule(_localctx, 192, LcypherParser::RuleOC_ReservedWord);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1585);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6917810502617792512) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -18014261578046465) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LeftArrowHeadContext ------------------------------------------------------------------

LcypherParser::OC_LeftArrowHeadContext::OC_LeftArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t LcypherParser::OC_LeftArrowHeadContext::getRuleIndex() const {
  return LcypherParser::RuleOC_LeftArrowHead;
}


std::any LcypherParser::OC_LeftArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_LeftArrowHead(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_LeftArrowHeadContext* LcypherParser::oC_LeftArrowHead() {
  OC_LeftArrowHeadContext *_localctx = _tracker.createInstance<OC_LeftArrowHeadContext>(_ctx, getState());
  enterRule(_localctx, 194, LcypherParser::RuleOC_LeftArrowHead);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1587);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 2013790208) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RightArrowHeadContext ------------------------------------------------------------------

LcypherParser::OC_RightArrowHeadContext::OC_RightArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t LcypherParser::OC_RightArrowHeadContext::getRuleIndex() const {
  return LcypherParser::RuleOC_RightArrowHead;
}


std::any LcypherParser::OC_RightArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_RightArrowHead(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_RightArrowHeadContext* LcypherParser::oC_RightArrowHead() {
  OC_RightArrowHeadContext *_localctx = _tracker.createInstance<OC_RightArrowHeadContext>(_ctx, getState());
  enterRule(_localctx, 196, LcypherParser::RuleOC_RightArrowHead);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1589);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 32213303296) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_DashContext ------------------------------------------------------------------

LcypherParser::OC_DashContext::OC_DashContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t LcypherParser::OC_DashContext::getRuleIndex() const {
  return LcypherParser::RuleOC_Dash;
}


std::any LcypherParser::OC_DashContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<LcypherVisitor*>(visitor))
    return parserVisitor->visitOC_Dash(this);
  else
    return visitor->visitChildren(this);
}

LcypherParser::OC_DashContext* LcypherParser::oC_Dash() {
  OC_DashContext *_localctx = _tracker.createInstance<OC_DashContext>(_ctx, getState());
  enterRule(_localctx, 198, LcypherParser::RuleOC_Dash);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1591);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 70334384455680) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

void LcypherParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  lcypherParserInitialize();
#else
  ::antlr4::internal::call_once(lcypherParserOnceFlag, lcypherParserInitialize);
#endif
}
